Attachment #166769 for bug #86520




			target="org.eclipse.core.runtime.xml, org.eclipse.wst.xml.core.xmlsource" />
		<provisionalDefinition
			type="activecontexts"
			value="org.eclipse.core.runtime.xml, org.eclipse.wst.xml.navigation, org.eclipse.wst.xml.cleanup, org.eclipse.wst.xml.selection, org.eclipse.wst.xml.dependencies, org.eclipse.wst.xml.grammar, org.eclipse.wst.xml.expand, org.eclipse.wst.xml.occurrences"
        	target="org.eclipse.core.runtime.xml" />
	</extension>
	

			id="org.eclipse.wst.xml.cleanup">
		</context>
		<context
			name="%scope.structured.text.editor.xml.comments.name"
			parentId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			description="%scope.structured.text.editor.xml.comments.description"
			id="org.eclipse.wst.xml.comments">
		</context>
		<context
			name="%scope.structured.text.editor.xml.selection.name"
			parentId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
			description="%scope.structured.text.editor.xml.selection.description"

           </command>
        </toolbar>
     </menuContribution>
     
     <menuContribution locationURI="menu:sourceMenuId?after=sourceBegin">
			<command commandId="org.eclipse.wst.sse.ui.toggle.comment"
			         id="ToggleComment"
			         mnemonic="%command.toggle.comment.mnemonic"
			         style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
				</visibleWhen>
			</command>
			<command commandId="org.eclipse.wst.sse.ui.add.block.comment"
			         id="AddBlockComment"
			         mnemonic="%command.add.block.comment.mnemonic"
			         style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
				</visibleWhen>
			</command>
			<command commandId="org.eclipse.wst.sse.ui.remove.block.comment"
			         id="RemoveBlockComment"
			         mnemonic="%command.remove.block.comment.mnemonic"
			         style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
				</visibleWhen>
			</command>
		</menuContribution>
		
		<menuContribution
	           locationURI="popup:sourcePopupMenuId?after=sourceBegin">
				<command commandId="org.eclipse.wst.sse.ui.toggle.comment" id="ToggleComment" style="push">
					<visibleWhen checkEnabled="false">
						<reference definitionId="org.eclipse.wst.xml.ui.comments"></reference>
					</visibleWhen>
				</command>
				<command commandId="org.eclipse.wst.sse.ui.add.block.comment" id="AddBlockComment" style="push">
					<visibleWhen checkEnabled="false">
						<reference definitionId="org.eclipse.wst.xml.ui.comments"></reference>
					</visibleWhen>
				</command>
				<command commandId="org.eclipse.wst.sse.ui.remove.block.comment" id="RemoveBlockComment" style="push">
					<visibleWhen checkEnabled="false">
						<reference definitionId="org.eclipse.wst.xml.ui.comments"></reference>
					</visibleWhen>
				</command>
				<separator name="format" visible="true"></separator>
		</menuContribution>
	</extension>
	
	<extension point="org.eclipse.core.expressions.definitions">

	</extension>
	
	<extension point="org.eclipse.core.expressions.definitions">
		<definition id="org.eclipse.wst.xml.ui.comments">
			<with variable="activeContexts">
				<iterate operator="or">
					<equals value="org.eclipse.wst.xml.comments"/>
				</iterate>
			</with>
		</definition>
	</extension>
	
	<extension point="org.eclipse.core.expressions.definitions">
		<definition id="org.eclipse.wst.xml.ui.cleanup">
			<with variable="activeContexts">
				<iterate operator="or">

          </enabledWhen>
       </handler>
       <handler
             class="org.eclipse.wst.xml.ui.internal.handlers.ToggleCommentHandler"
             commandId="org.eclipse.wst.sse.ui.toggle.comment">
          <activeWhen>
              <reference definitionId="org.eclipse.wst.xml.ui.comments"/>
          </activeWhen>
          <enabledWhen>
              <reference definitionId="org.eclipse.wst.xml.ui.comments"/>
          </enabledWhen>
       </handler>
       <handler
             class="org.eclipse.wst.xml.ui.internal.handlers.AddBlockCommentHandler"
             commandId="org.eclipse.wst.sse.ui.add.block.comment">
          <activeWhen>
              <reference definitionId="org.eclipse.wst.xml.ui.comments"/>
          </activeWhen>
          <enabledWhen>
              <reference definitionId="org.eclipse.wst.xml.ui.comments"/>
          </enabledWhen>
       </handler>
       <handler
             class="org.eclipse.wst.xml.ui.internal.handlers.RemoveBlockCommentHandler"
             commandId="org.eclipse.wst.sse.ui.remove.block.comment">
          <activeWhen>
              <reference definitionId="org.eclipse.wst.xml.ui.comments"/>
          </activeWhen>
          <enabledWhen>
              <reference definitionId="org.eclipse.wst.xml.ui.comments"/>
          </enabledWhen>
       </handler>
       <handler
             class="org.eclipse.wst.xml.ui.internal.handlers.StructuredSelectEnclosingXMLHandler"
             commandId="org.eclipse.wst.sse.ui.structure.select.enclosing">
          <activeWhen>

    </inserter>
 </extension>
 <extension
       point="org.eclipse.wst.sse.ui.commentingStrategy">
    <blockCommentingStrategy
          prefix="&lt;!--"
          suffix="--&gt;">
       <contentType
             id="org.eclipse.core.runtime.xml"
             associatedCommentPartitionTypeID="org.eclipse.wst.xml.XML_COMMENT">
          <allowablePartitionTypes
                anyPartitionType="true">
          </allowablePartitionTypes>
       </contentType>
    </blockCommentingStrategy>
 </extension>
 <extension
       point="org.eclipse.wst.sse.ui.completionProposal">
    <proposalCategory
          icon="icons/full/obj16/tag-generic.gif"




Colors.cdataBorder=CDATA Border
Colors.cdataText=CDATA Text
Colors.entityReference=Entity Reference

# Menu contributions
command.toggle.comment.mnemonic=T
command.add.block.comment.mnemonic=A
command.remove.block.comment.mnemonic=R

# content assist
proposalCategory.xmlTags=XML Tag Proposals
proposalCategory.xmlTemplates=XML Template Proposals




/*******************************************************************************
 * Copyright (c) 2008 Standards for Technology in Automotive Retail 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:
 *     David Carver - initial API and implementation, bug 212330
 *     
 *******************************************************************************/
package org.eclipse.wst.xml.ui.internal.handlers;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandler;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.handlers.HandlerUtil;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.xml.ui.internal.Logger;

public class CommentHandler extends AbstractHandler implements IHandler {
	static final String CLOSE_COMMENT = "-->"; //$NON-NLS-1$
	static final String OPEN_COMMENT = "<!--"; //$NON-NLS-1$

	public CommentHandler() {
		super();
	}

	public Object execute(ExecutionEvent event) throws ExecutionException {
		IEditorPart editor = HandlerUtil.getActiveEditor(event);
		ITextEditor textEditor = null;
		if (editor instanceof ITextEditor)
			textEditor = (ITextEditor) editor;
		else {
			Object o = editor.getAdapter(ITextEditor.class);
			if (o != null)
				textEditor = (ITextEditor) o;
		}
		if (textEditor != null) {
			IDocument document = textEditor.getDocumentProvider().getDocument(textEditor.getEditorInput());
			if (document != null) {
				// get current text selection
				ITextSelection textSelection = getCurrentSelection(textEditor);
				if (textSelection.isEmpty()) {
					return null;
				}

				processAction(textEditor, document, textSelection);
			}
		}

		return null;
	}

	protected ITextSelection getCurrentSelection(ITextEditor textEditor) {
		ISelectionProvider provider = textEditor.getSelectionProvider();
		if (provider != null) {
			ISelection selection = provider.getSelection();
			if (selection instanceof ITextSelection) {
				return (ITextSelection) selection;
			}
		}
		return TextSelection.emptySelection();
	}

	void processAction(ITextEditor textEditor, IDocument document, ITextSelection textSelection) {
		// Implementations to over ride.
	}

	protected void removeOpenCloseComments(IDocument document, int offset, int length) {
		try {
			int adjusted_length = length;

			// remove open comments
			String string = document.get(offset, length);
			int index = string.lastIndexOf(OPEN_COMMENT);
			while (index != -1) {
				document.replace(offset + index, OPEN_COMMENT.length(), ""); //$NON-NLS-1$
				index = string.lastIndexOf(OPEN_COMMENT, index - 1);
				adjusted_length -= OPEN_COMMENT.length();
			}

			// remove close comments
			string = document.get(offset, adjusted_length);
			index = string.lastIndexOf(CLOSE_COMMENT);
			while (index != -1) {
				document.replace(offset + index, CLOSE_COMMENT.length(), ""); //$NON-NLS-1$
				index = string.lastIndexOf(CLOSE_COMMENT, index - 1);
			}
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Standards for Technology in Automotive Retail 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:
 *     David Carver - initial API and implementation, bug 212330
 *     
 *******************************************************************************/
package org.eclipse.wst.xml.ui.internal.handlers;

import org.eclipse.core.commands.IHandler;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.xml.core.internal.document.CommentImpl;
import org.eclipse.wst.xml.ui.internal.Logger;
import org.eclipse.wst.xml.ui.internal.XMLUIMessages;

/**
 * @author dcarver
 * 
 */
public class RemoveBlockCommentHandler extends CommentHandler implements IHandler {

	public RemoveBlockCommentHandler() {
		super();
	}

	void processAction(ITextEditor textEditor, IDocument document, ITextSelection textSelection) {
		IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForEdit(document);
		if (model != null) {
			try {
				IndexedRegion selectionStartIndexedRegion = model.getIndexedRegion(textSelection.getOffset());
				IndexedRegion selectionEndIndexedRegion = model.getIndexedRegion(textSelection.getOffset() + textSelection.getLength());

				if ((selectionStartIndexedRegion == null) || (selectionEndIndexedRegion == null)) {
					return;
				}

				int openCommentOffset = selectionStartIndexedRegion.getStartOffset();
				int closeCommentOffset = selectionEndIndexedRegion.getEndOffset() - OPEN_COMMENT.length() - CLOSE_COMMENT.length();

				model.beginRecording(this, XMLUIMessages.RemoveBlockComment_tooltip);
				model.aboutToChangeModel();

				try {
					if (textSelection.getLength() == 0) {
						if (selectionStartIndexedRegion instanceof CommentImpl) {
							document.replace(openCommentOffset, OPEN_COMMENT.length(), ""); //$NON-NLS-1$
							document.replace(closeCommentOffset, CLOSE_COMMENT.length(), ""); //$NON-NLS-1$
						}
					}
					else {
						if (selectionStartIndexedRegion instanceof CommentImpl) {
							document.replace(openCommentOffset, OPEN_COMMENT.length(), ""); //$NON-NLS-1$
						}

						if (selectionEndIndexedRegion instanceof CommentImpl) {
							document.replace(closeCommentOffset, CLOSE_COMMENT.length(), ""); //$NON-NLS-1$
						}
					}
					removeOpenCloseComments(document, openCommentOffset + OPEN_COMMENT.length(), closeCommentOffset - openCommentOffset - CLOSE_COMMENT.length());
				}
				catch (BadLocationException e) {
					Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
				}
				finally {
					model.changedModel();
					model.endRecording(this);
				}
			}
			finally {
				model.releaseFromEdit();
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Standards for Technology in Automotive Retail 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:
 *     David Carver - initial API and implementation, bug 212330
 *     
 *******************************************************************************/
package org.eclipse.wst.xml.ui.internal.handlers;

import org.eclipse.core.commands.IHandler;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.xml.core.internal.document.CommentImpl;
import org.eclipse.wst.xml.ui.internal.Logger;
import org.eclipse.wst.xml.ui.internal.XMLUIMessages;

public class AddBlockCommentHandler extends CommentHandler implements IHandler {

	public AddBlockCommentHandler() {
		super();
	}

	void processAction(ITextEditor textEditor, IDocument document, ITextSelection textSelection) {
		IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForEdit(document);
		if (model != null) {
			try {
				IndexedRegion selectionStartIndexedRegion = model.getIndexedRegion(textSelection.getOffset());
				IndexedRegion selectionEndIndexedRegion = model.getIndexedRegion(textSelection.getOffset() + textSelection.getLength());

				if (selectionStartIndexedRegion == null) {
					return;
				}
				if ((selectionEndIndexedRegion == null) && (textSelection.getLength() > 0)) {
					selectionEndIndexedRegion = model.getIndexedRegion(textSelection.getOffset() + textSelection.getLength() - 1);
				}
				if (selectionEndIndexedRegion == null) {
					return;
				}

				int openCommentOffset = selectionStartIndexedRegion.getStartOffset();
				int closeCommentOffset = selectionEndIndexedRegion.getEndOffset() + OPEN_COMMENT.length();

				if ((textSelection.getLength() == 0) && (selectionStartIndexedRegion instanceof CommentImpl)) {
					return;
				}

				model.beginRecording(this, XMLUIMessages.AddBlockComment_tooltip);
				model.aboutToChangeModel();

				try {
					document.replace(openCommentOffset, 0, OPEN_COMMENT);
					document.replace(closeCommentOffset, 0, CLOSE_COMMENT);
					super.removeOpenCloseComments(document, openCommentOffset + OPEN_COMMENT.length(), closeCommentOffset - openCommentOffset - CLOSE_COMMENT.length());
				}
				catch (BadLocationException e) {
					Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
				}
				finally {
					model.changedModel();
					model.endRecording(this);
				}
			}
			finally {
				model.releaseFromEdit();
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Standards for Technology in Automotive Retail 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:
 *     David Carver - initial API and implementation, bug 212330
 *     
 *******************************************************************************/
package org.eclipse.wst.xml.ui.internal.handlers;

import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandler;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.handlers.HandlerUtil;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.xml.ui.internal.Logger;
import org.eclipse.wst.xml.ui.internal.XMLUIMessages;

public class ToggleCommentHandler extends CommentHandler implements IHandler {
	public ToggleCommentHandler() {
		super();
	}

	public Object execute(ExecutionEvent event) throws ExecutionException {
		IEditorPart editor = HandlerUtil.getActiveEditor(event);
		ITextEditor textEditor = null;
		if (editor instanceof ITextEditor)
			textEditor = (ITextEditor) editor;
		else {
			Object o = editor.getAdapter(ITextEditor.class);
			if (o != null)
				textEditor = (ITextEditor) o;
		}
		if (textEditor != null) {
			IDocument document = textEditor.getDocumentProvider().getDocument(textEditor.getEditorInput());
			if (document != null) {
				// get current text selection
				ITextSelection textSelection = getCurrentSelection(textEditor);
				if (textSelection.isEmpty()) {
					return null;
				}

				processAction(textEditor, document, textSelection);
			}
		}
		return null;
	}

	void processAction(ITextEditor textEditor, IDocument document, ITextSelection textSelection) {
		// get text selection lines info
		int selectionStartLine = textSelection.getStartLine();
		int selectionEndLine = textSelection.getEndLine();
		try {
			int selectionEndLineOffset = document.getLineOffset(selectionEndLine);
			int selectionEndOffset = textSelection.getOffset() + textSelection.getLength();

			// adjust selection end line
			if ((selectionEndLine > selectionStartLine) && (selectionEndLineOffset == selectionEndOffset)) {
				selectionEndLine--;
			}

		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}

		// save the selection position since it will be changing
		Position selectionPosition = null;
		boolean updateStartOffset = false;
		try {
			selectionPosition = new Position(textSelection.getOffset(), textSelection.getLength());
			document.addPosition(selectionPosition);

			// extra check if commenting from beginning of line
			int selectionStartLineOffset = document.getLineOffset(selectionStartLine);
			if ((textSelection.getLength() > 0) && (selectionStartLineOffset == textSelection.getOffset()) && !isCommentLine(document, selectionStartLine)) {
				updateStartOffset = true;
			}
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}

		processAction(document, selectionStartLine, selectionEndLine);

		updateCurrentSelection(textEditor, selectionPosition, document, updateStartOffset);
	}

	private void processAction(IDocument document, int selectionStartLine, int selectionEndLine) {
		IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForEdit(document);
		if (model != null) {
			try {
				model.beginRecording(this, XMLUIMessages.ToggleComment_tooltip);
				model.aboutToChangeModel();

				for (int i = selectionStartLine; i <= selectionEndLine; i++) {
					try {
						if (document.getLineLength(i) > 0) {
							if (isCommentLine(document, i)) {
								int lineOffset = document.getLineOffset(i);
								IRegion region = document.getLineInformation(i);
								String string = document.get(region.getOffset(), region.getLength());
								int openCommentOffset = lineOffset + string.indexOf(OPEN_COMMENT);
								int closeCommentOffset = lineOffset + string.indexOf(CLOSE_COMMENT) - OPEN_COMMENT.length();
								uncomment(document, openCommentOffset, closeCommentOffset);
							}
							else {
								int openCommentOffset = document.getLineOffset(i);
								int lineDelimiterLength = document.getLineDelimiter(i) == null ? 0 : document.getLineDelimiter(i).length();
								int closeCommentOffset = openCommentOffset + document.getLineLength(i) - lineDelimiterLength + OPEN_COMMENT.length();
								comment(document, openCommentOffset, closeCommentOffset);
							}
						}
					}
					catch (BadLocationException e) {
						Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
					}
				}
			}
			finally {
				model.changedModel();
				model.endRecording(this);
				model.releaseFromEdit();
			}
		}
	}

	private boolean isCommentLine(IDocument document, int line) {
		boolean isComment = false;

		try {
			IRegion region = document.getLineInformation(line);
			String string = document.get(region.getOffset(), region.getLength()).trim();
			isComment = (string.length() >= OPEN_COMMENT.length() + CLOSE_COMMENT.length()) && string.startsWith(OPEN_COMMENT) && string.endsWith(CLOSE_COMMENT);
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}
		return isComment;
	}

	private void comment(IDocument document, int openCommentOffset, int closeCommentOffset) {
		try {
			document.replace(openCommentOffset, 0, OPEN_COMMENT);
			document.replace(closeCommentOffset, 0, CLOSE_COMMENT);
			removeOpenCloseComments(document, openCommentOffset + OPEN_COMMENT.length(), closeCommentOffset - openCommentOffset - CLOSE_COMMENT.length());
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}
	}

	private void uncomment(IDocument document, int openCommentOffset, int closeCommentOffset) {
		try {
			document.replace(openCommentOffset, OPEN_COMMENT.length(), ""); //$NON-NLS-1$
			document.replace(closeCommentOffset, CLOSE_COMMENT.length(), ""); //$NON-NLS-1$
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}
	}

	private void updateCurrentSelection(ITextEditor textEditor, Position selectionPosition, IDocument document, boolean updateStartOffset) {
		// update the selection if text selection changed
		if (selectionPosition != null) {
			ITextSelection selection = null;
			if (updateStartOffset) {
				selection = new TextSelection(document, selectionPosition.getOffset() - OPEN_COMMENT.length(), selectionPosition.getLength() + OPEN_COMMENT.length());
			}
			else {
				selection = new TextSelection(document, selectionPosition.getOffset(), selectionPosition.getLength());
			}
			ISelectionProvider provider = textEditor.getSelectionProvider();
			if (provider != null) {
				provider.setSelection(selection);
			}
			document.removePosition(selectionPosition);
		}
	}
}




			target="org.eclipse.wst.html.core.htmlsource" />
		<provisionalDefinition
			type="activecontexts"
			value="org.eclipse.wst.html.core.htmlsource, org.eclipse.wst.html.occurrences, org.eclipse.core.runtime.xml, org.eclipse.wst.xml.navigation, org.eclipse.wst.xml.selection, org.eclipse.wst.sse.comments"
        	target="org.eclipse.wst.html.core.htmlsource" />
	</extension>
	<extension

			</enabledWhen>
		</handler>
	</extension>

	<extension
       point="org.eclipse.wst.sse.ui.commentingStrategy">
    <blockCommentingStrategy
          prefix="&lt;!--"
          suffix="--&gt;">
       <contentType
             id="org.eclipse.wst.html.core.htmlsource"
             associatedCommentPartitionTypeID="org.eclipse.wst.html.HTML_COMMENT">
          <requiredPartitionTypes
                requireAll="false">
             <partitionType
                   id="org.eclipse.wst.html.HTML_DEFAULT">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.html.HTML_DECLARATION">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.html.SCRIPT.EVENTHANDLER">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.xml.XML_PI">
             </partitionType>
          </requiredPartitionTypes>
          <allowablePartitionTypes
                anyPartitionType="false">
             <partitionType
                   id="org.eclipse.wst.css.STYLE">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.html.SCRIPT">
             </partitionType>
          </allowablePartitionTypes>
       </contentType>
    </blockCommentingStrategy>
 </extension>
	<!-- Set up a definition for HTML Content Types -->
	<extension point="org.eclipse.core.expressions.definitions">
		<definition id="org.eclipse.wst.html.ui.htmlContentType.definition">




			target="org.eclipse.wst.css.core.csssource" />
		<provisionalDefinition
			type="activecontexts"
			value="org.eclipse.wst.css.core.csssource, org.eclipse.wst.sse.comments"
			target="org.eclipse.wst.css.core.csssource" />
	</extension>
	

			</enabledWhen>
		</handler>
		<handler
             class="org.eclipse.wst.css.ui.internal.handlers.ToggleCommentHandler"
             commandId="org.eclipse.wst.sse.ui.toggle.comment">
             <activeWhen>
             	<reference
                    definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
             	</reference>
             </activeWhen>
             <enabledWhen>
             	<reference
                    definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
             	</reference>
             </enabledWhen>
       </handler>
       <handler
             class="org.eclipse.wst.css.ui.internal.handlers.AddBlockCommentHandler"
             commandId="org.eclipse.wst.sse.ui.add.block.comment">
             <activeWhen>
             	<reference
                    definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
             	</reference>
             </activeWhen>
             <enabledWhen>
             	<reference
                    definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
             	</reference>
             </enabledWhen>
       </handler>
       <handler
             class="org.eclipse.wst.css.ui.internal.handlers.RemoveBlockCommentHandler"
             commandId="org.eclipse.wst.sse.ui.remove.block.comment">
             <activeWhen>
             	<reference
                    definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
             	</reference>
             </activeWhen>
             <enabledWhen>
             	<reference
                    definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
             	</reference>
             </enabledWhen>
       </handler>
		<handler
			class="org.eclipse.wst.css.ui.internal.handlers.StructuredSelectEnclosingHandler"
			commandId="org.eclipse.wst.sse.ui.structure.select.enclosing">
			<activeWhen>

		</handler>
	</extension>

	<extension point="org.eclipse.ui.menus">
		<menuContribution
	       locationURI="popup:sourcePopupMenuId?before=sourceBegin">
			<command commandId="org.eclipse.wst.sse.ui.toggle.comment" id="ToggleComment" style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition"/>
				</visibleWhen>
			</command>
			<command commandId="org.eclipse.wst.sse.ui.add.block.comment" id="AddBlockComment" style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition" />
				</visibleWhen>
			</command>
			<command commandId="org.eclipse.wst.sse.ui.remove.block.comment" id="RemoveBlockComment" style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition" />
				</visibleWhen>
			</command>
		</menuContribution>

		<menuContribution locationURI="menu:sourceMenuId?before=sourceBegin">
			<command commandId="org.eclipse.wst.sse.ui.toggle.comment"
			         id="ToggleComment"
			         mnemonic="%command.toggle.comment.mnemonic"
			         style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition"/>
				</visibleWhen>
			</command>
			<command commandId="org.eclipse.wst.sse.ui.add.block.comment"
			         id="AddBlockComment"
			         mnemonic="%command.add.block.comment.mnemonic"
			         style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition"/>
				</visibleWhen>
			</command>
			<command commandId="org.eclipse.wst.sse.ui.remove.block.comment"
			         id="RemoveBlockComment"
			         mnemonic="%command.remove.block.comment.mnemonic"
			         style="push">
				<visibleWhen checkEnabled="false">
					<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition"/>
				</visibleWhen>
			</command>
		</menuContribution>
	</extension>
	<!-- CSS editor actions -->
	<extension point="org.eclipse.ui.editorActions">
		<!--<editorContribution

		</inserter>
	</extension>
 <extension
       point="org.eclipse.wst.sse.ui.commentingStrategy">
    <blockCommentingStrategy
          prefix="/*"
          suffix="*/">
       <contentType
             id="org.eclipse.wst.html.core.htmlsource">
          <allowablePartitionTypes
                anyPartitionType="false">
          </allowablePartitionTypes>
          <requiredPartitionTypes
                requireAll="true">
             <partitionType
                   id="org.eclipse.wst.css.STYLE">
             </partitionType>
          </requiredPartitionTypes>
       </contentType>
       <contentType
             associatedCommentPartitionTypeID="org.eclipse.wst.css.COMMENT"
             id="org.eclipse.wst.css.core.csssource">
          <allowablePartitionTypes
                anyPartitionType="true">
          </allowablePartitionTypes>
       </contentType>
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <allowablePartitionTypes
                anyPartitionType="false">
          </allowablePartitionTypes>
          <requiredPartitionTypes
                requireAll="true">
             <partitionType
                   id="org.eclipse.wst.css.STYLE">
             </partitionType>
          </requiredPartitionTypes>
       </contentType>
    </blockCommentingStrategy>
 </extension>
 <extension
       point="org.eclipse.wst.sse.ui.completionProposal">
    <proposalCategory
          icon="icons/full/obj16/tag_selector.gif"

Lines 57-66 Link Here

(-)plugin.properties (-4 lines)
57	scope.structured.text.editor.css.name=Editing CSS Source	57	scope.structured.text.editor.css.name=Editing CSS Source
58	scope.structured.text.editor.css.description=Editing CSS Source	58	scope.structured.text.editor.css.description=Editing CSS Source
59		59
60	command.toggle.comment.mnemonic=T
61	command.remove.block.comment.mnemonic=R
62	command.add.block.comment.mnemonic=A
63
64	Colors.atmarkRule=At Mark Rule	60	Colors.atmarkRule=At Mark Rule
65	Colors.selector=Selector	61	Colors.selector=Selector
66	Colors.media=Media	62	Colors.media=Media




/*******************************************************************************
 * Copyright (c) 2009 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
 *******************************************************************************/
package org.eclipse.wst.css.ui.internal.handlers;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.css.ui.internal.Logger;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.css.ui.internal.CSSUIMessages;

public class ToggleCommentHandler extends AbstractCommentHandler {

	protected void processAction(ITextEditor textEditor, IDocument document, ITextSelection textSelection) {
		// get text selection lines info
		int selectionStartLine = textSelection.getStartLine();
		int selectionEndLine = textSelection.getEndLine();
		try {
			int selectionEndLineOffset = document.getLineOffset(selectionEndLine);
			int selectionEndOffset = textSelection.getOffset() + textSelection.getLength();

			// adjust selection end line
			if ((selectionEndLine > selectionStartLine) && (selectionEndLineOffset == selectionEndOffset)) {
				selectionEndLine--;
			}

		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}

		// save the selection position since it will be changing
		Position selectionPosition = null;
		boolean updateStartOffset = false;
		try {
			selectionPosition = new Position(textSelection.getOffset(), textSelection.getLength());
			document.addPosition(selectionPosition);

			// extra check if commenting from beginning of line
			int selectionStartLineOffset = document.getLineOffset(selectionStartLine);
			if ((textSelection.getLength() > 0) && (selectionStartLineOffset == textSelection.getOffset()) && !isCommentLine(document, selectionStartLine)) {
				updateStartOffset = true;
			}
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}

		processAction(document, selectionStartLine, selectionEndLine);

		updateCurrentSelection(textEditor, selectionPosition, document, updateStartOffset);
	}

	private void processAction(IDocument document, int selectionStartLine, int selectionEndLine) {
		IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForEdit(document);
		if (model != null) {
			try {
				model.beginRecording(this, CSSUIMessages.ToggleComment_tooltip);
				model.aboutToChangeModel();

				for (int i = selectionStartLine; i <= selectionEndLine; i++) {
					try {
						if (document.getLineLength(i) > 0) {
							if (isCommentLine(document, i)) {
								int lineOffset = document.getLineOffset(i);
								IRegion region = document.getLineInformation(i);
								String string = document.get(region.getOffset(), region.getLength());
								int openCommentOffset = lineOffset + string.indexOf(OPEN_COMMENT);
								int closeCommentOffset = lineOffset + string.indexOf(CLOSE_COMMENT) - OPEN_COMMENT.length();
								uncomment(document, openCommentOffset, closeCommentOffset);
							}
							else {
								int openCommentOffset = document.getLineOffset(i);
								int lineDelimiterLength = document.getLineDelimiter(i) == null ? 0 : document.getLineDelimiter(i).length();
								int closeCommentOffset = openCommentOffset + document.getLineLength(i) - lineDelimiterLength + OPEN_COMMENT.length();
								comment(document, openCommentOffset, closeCommentOffset);
							}
						}
					}
					catch (BadLocationException e) {
						Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
					}
				}
			}
			finally {
				model.changedModel();
				model.endRecording(this);
				model.releaseFromEdit();
			}
		}
	}

	private void updateCurrentSelection(ITextEditor textEditor, Position selectionPosition, IDocument document, boolean updateStartOffset) {
		// update the selection if text selection changed
		if (selectionPosition != null) {
			ITextSelection selection = null;
			if (updateStartOffset) {
				selection = new TextSelection(document, selectionPosition.getOffset() - OPEN_COMMENT.length(), selectionPosition.getLength() + OPEN_COMMENT.length());
			}
			else {
				selection = new TextSelection(document, selectionPosition.getOffset(), selectionPosition.getLength());
			}
			ISelectionProvider provider = textEditor.getSelectionProvider();
			if (provider != null) {
				provider.setSelection(selection);
			}
			document.removePosition(selectionPosition);
		}
	}

	private boolean isCommentLine(IDocument document, int line) {
		boolean isComment = false;

		try {
			IRegion region = document.getLineInformation(line);
			String string = document.get(region.getOffset(), region.getLength()).trim();
			isComment = (string.length() >= OPEN_COMMENT.length() + CLOSE_COMMENT.length()) && string.startsWith(OPEN_COMMENT) && string.endsWith(CLOSE_COMMENT);
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}
		return isComment;
	}

	private void comment(IDocument document, int openCommentOffset, int closeCommentOffset) {
		try {
			document.replace(openCommentOffset, 0, OPEN_COMMENT);
			document.replace(closeCommentOffset, 0, CLOSE_COMMENT);
			removeOpenCloseComments(document, openCommentOffset + OPEN_COMMENT.length(), closeCommentOffset - openCommentOffset - CLOSE_COMMENT.length());
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}
	}

	private void uncomment(IDocument document, int openCommentOffset, int closeCommentOffset) {
		try {
			document.replace(openCommentOffset, OPEN_COMMENT.length(), ""); //$NON-NLS-1$
			document.replace(closeCommentOffset, CLOSE_COMMENT.length(), ""); //$NON-NLS-1$
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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
 *******************************************************************************/
package org.eclipse.wst.css.ui.internal.handlers;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.handlers.HandlerUtil;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.css.ui.internal.Logger;

public class AbstractCommentHandler extends AbstractHandler {

	static final String OPEN_COMMENT = "/*"; //$NON-NLS-1$
	static final String CLOSE_COMMENT = "*/"; //$NON-NLS-1$

	public Object execute(ExecutionEvent event) throws ExecutionException {
		ITextEditor textEditor = getTextEditor(event);
		if (textEditor != null) {
			IDocument document = textEditor.getDocumentProvider().getDocument(textEditor.getEditorInput());
			if (document != null) {
				// get current text selection
				ITextSelection textSelection = getCurrentSelection(textEditor);
				if (textSelection.isEmpty()) {
					return null;
				}

				processAction(textEditor, document, textSelection);
			}
		}

		return null;
	}

	protected void processAction(ITextEditor editor, IDocument document, ITextSelection textSelection) {
	}

	protected ITextEditor getTextEditor(ExecutionEvent event) {
		IEditorPart editor = HandlerUtil.getActiveEditor(event);
		ITextEditor textEditor = null;
		if (editor instanceof ITextEditor)
			textEditor = (ITextEditor) editor;
		else {
			Object o = editor.getAdapter(ITextEditor.class);
			if (o != null)
				textEditor = (ITextEditor) o;
		}
		return textEditor;
	}

	protected ITextSelection getCurrentSelection(ITextEditor textEditor) {
		ISelectionProvider provider = textEditor.getSelectionProvider();
		if (provider != null) {
			ISelection selection = provider.getSelection();
			if (selection instanceof ITextSelection) {
				return (ITextSelection) selection;
			}
		}
		return TextSelection.emptySelection();
	}

	protected void removeOpenCloseComments(IDocument document, int offset, int length) {
		try {
			int adjusted_length = length;

			// remove open comments
			String string = document.get(offset, length);
			int index = string.lastIndexOf(OPEN_COMMENT);
			while (index != -1) {
				document.replace(offset + index, OPEN_COMMENT.length(), ""); //$NON-NLS-1$
				index = string.lastIndexOf(OPEN_COMMENT, index - 1);
				adjusted_length -= OPEN_COMMENT.length();
			}

			// remove close comments
			string = document.get(offset, adjusted_length);
			index = string.lastIndexOf(CLOSE_COMMENT);
			while (index != -1) {
				document.replace(offset + index, CLOSE_COMMENT.length(), ""); //$NON-NLS-1$
				index = string.lastIndexOf(CLOSE_COMMENT, index - 1);
			}
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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
 *******************************************************************************/
package org.eclipse.wst.css.ui.internal.handlers;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.css.core.internal.parserz.CSSRegionContexts;
import org.eclipse.wst.css.ui.internal.Logger;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.css.ui.internal.CSSUIMessages;

public class AddBlockCommentHandler extends AbstractCommentHandler {

	protected void processAction(ITextEditor textEditor, IDocument document, ITextSelection textSelection) {
		IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForEdit(document);
		if (model != null && document instanceof IStructuredDocument) {
			try {
				IStructuredDocument doc = (IStructuredDocument) document;
				IStructuredDocumentRegion startRegion = doc.getRegionAtCharacterOffset(textSelection.getOffset());
				IStructuredDocumentRegion endRegion = doc.getRegionAtCharacterOffset(textSelection.getOffset() + textSelection.getLength());

				if (startRegion == null) {
					return;
				}
				if ((endRegion == null) && (textSelection.getLength() > 0)) {
					endRegion = doc.getRegionAtCharacterOffset(textSelection.getOffset() + textSelection.getLength() - 1);
				}
				if (endRegion == null) {
					return;
				}

				int openCommentOffset = startRegion.getStartOffset();
				int closeCommentOffset = endRegion.getEndOffset() + CLOSE_COMMENT.length();

				if ((textSelection.getLength() == 0) && (startRegion.getType() == CSSRegionContexts.CSS_COMMENT)) {
					return;
				}

				model.beginRecording(this, CSSUIMessages.AddBlockComment_tooltip);
				model.aboutToChangeModel();

				try {
					document.replace(openCommentOffset, 0, OPEN_COMMENT);
					document.replace(closeCommentOffset, 0, CLOSE_COMMENT);
					super.removeOpenCloseComments(document, openCommentOffset + OPEN_COMMENT.length(), closeCommentOffset - openCommentOffset - CLOSE_COMMENT.length());
				}
				catch (BadLocationException e) {
					Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
				}
				finally {
					model.changedModel();
					model.endRecording(this);
				}
			}
			finally {
				model.releaseFromEdit();
			}
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2009 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
 *******************************************************************************/
package org.eclipse.wst.css.ui.internal.handlers;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.css.core.internal.parserz.CSSRegionContexts;
import org.eclipse.wst.css.ui.internal.Logger;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.css.ui.internal.CSSUIMessages;

public class RemoveBlockCommentHandler extends AbstractCommentHandler {

	protected void processAction(ITextEditor textEditor, IDocument document, ITextSelection textSelection) {
		IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForEdit(document);
		if (model != null && document instanceof IStructuredDocument) {
			try {
				IStructuredDocument doc = (IStructuredDocument) document;
				IStructuredDocumentRegion startRegion = doc.getRegionAtCharacterOffset(textSelection.getOffset());
				IStructuredDocumentRegion endRegion = doc.getRegionAtCharacterOffset(textSelection.getOffset() + textSelection.getLength());

				if ((startRegion == null) || (endRegion == null)) {
					return;
				}

				int openCommentOffset = startRegion.getStartOffset();
				int closeCommentOffset = endRegion.getEndOffset() - OPEN_COMMENT.length() - CLOSE_COMMENT.length();

				model.beginRecording(this, CSSUIMessages.RemoveBlockComment_tooltip);
				model.aboutToChangeModel();

				try {
					if (textSelection.getLength() == 0) {
						if (startRegion.getType() == CSSRegionContexts.CSS_COMMENT) {
							document.replace(openCommentOffset, OPEN_COMMENT.length(), ""); //$NON-NLS-1$
							document.replace(closeCommentOffset, CLOSE_COMMENT.length(), ""); //$NON-NLS-1$
						}
					}
					else {
						if (startRegion.getType() == CSSRegionContexts.CSS_COMMENT) {
							document.replace(openCommentOffset, OPEN_COMMENT.length(), ""); //$NON-NLS-1$
						}

						if (endRegion.getType() == CSSRegionContexts.CSS_COMMENT) {
							document.replace(closeCommentOffset, CLOSE_COMMENT.length(), ""); //$NON-NLS-1$
						}
					}
					removeOpenCloseComments(document, openCommentOffset + OPEN_COMMENT.length(), closeCommentOffset - openCommentOffset - CLOSE_COMMENT.length());
				}
				catch (BadLocationException e) {
					Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
				}
				finally {
					model.changedModel();
					model.endRecording(this);
				}
			}
			finally {
				model.releaseFromEdit();
			}
		}
	}

}




			target="org.eclipse.jst.jsp.core.jspsource" />
		<provisionalDefinition
			type="activecontexts"
			value="org.eclipse.jst.jsp.core.jspsource, org.eclipse.jst.jsp.ui.structured.text.editor.jsp.scope, org.eclipse.wst.html.core.htmlsource, org.eclipse.core.runtime.xml, org.eclipse.wst.xml.navigation, org.eclipse.wst.xml.selection, , org.eclipse.wst.sse.comments"
        	target="org.eclipse.jst.jsp.core.jspsource" />

		<contentOutlineConfiguration

		</inserter>
	</extension>
 <extension
       point="org.eclipse.wst.sse.ui.commentingStrategy">
    <blockCommentingStrategy
          prefix="&lt;!--"
          suffix="--&gt;">
       <contentType
             associatedCommentPartitionTypeID="org.eclipse.wst.html.HTML_COMMENT"
             id="org.eclipse.jst.jsp.core.jspsource">
          <requiredPartitionTypes
                requireAll="false">
             <partitionType
                   id="org.eclipse.wst.html.HTML_DEFAULT">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.html.HTML_DECLARATION">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.html.SCRIPT.EVENTHANDLER">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.xml.XML_PI">
             </partitionType>
          </requiredPartitionTypes>
          <allowablePartitionTypes
                anyPartitionType="false">
             <partitionType
                   id="org.eclipse.wst.css.STYLE">
             </partitionType>
             <partitionType
                   id="org.eclipse.wst.html.SCRIPT">
             </partitionType>
          </allowablePartitionTypes>
       </contentType>
    </blockCommentingStrategy>
    <blockCommentingStrategy
          prefix="&lt;%--"
          suffix="--%&gt;">
       <contentType
             associatedCommentPartitionTypeID="org.eclipse.jst.jsp.JSP_COMMENT"
             id="org.eclipse.jst.jsp.core.jspsource">
          <requiredPartitionTypes
                requireAll="false">
             <partitionType
                   id="org.eclipse.jst.jsp.JSP_DIRECTIVE">
             </partitionType>
             <partitionType
                   id="org.eclipse.jst.jsp.DEFAULT_JSP">
             </partitionType>
             <partitionType
                   id="org.eclipse.jst.jsp.SCRIPT.DELIMITER">
             </partitionType>
             <partitionType
                   id="org.eclipse.jst.jsp.SCRIPT.JSP_EL">
             </partitionType>
             <partitionType
                   id="org.eclipse.jst.jsp.SCRIPT.JSP_EL2">
             </partitionType>
          </requiredPartitionTypes>
          <allowablePartitionTypes
                anyPartitionType="true">
          </allowablePartitionTypes>
       </contentType>
    </blockCommentingStrategy>
    <blockCommentingStrategy
          prefix="/*"
          suffix="*/">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <requiredPartitionTypes
                requireAll="false">
             <partitionType
                   id="org.eclipse.jst.jsp.SCRIPT.JAVA">
             </partitionType>
          </requiredPartitionTypes>
          <allowablePartitionTypes
                anyPartitionType="false">
          </allowablePartitionTypes>
       </contentType>
    </blockCommentingStrategy>
    <lineCommentingStrategy
          prefix="//">
       <contentType
             id="org.eclipse.jst.jsp.core.jspsource">
          <requiredPartitionTypes
                requireAll="false">
             <partitionType
                   id="org.eclipse.jst.jsp.SCRIPT.JAVA">
             </partitionType>
          </requiredPartitionTypes>
          <allowablePartitionTypes
                anyPartitionType="false">
          </allowablePartitionTypes>
       </contentType>
    </lineCommentingStrategy>
 </extension>
 <extension
       point="org.eclipse.wst.sse.ui.completionProposal">
    <proposalCategory
          icon="icons/full/obj16/tag-template.gif"

Lines 1-5 Link Here

(-)src/org/eclipse/wst/html/core/text/IHTMLPartitions.java (-1 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2007 IBM Corporation and others.	2	* Copyright (c) 2005, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 26-31 Link Here
26		26
27	String SCRIPT = "org.eclipse.wst.html.SCRIPT"; //$NON-NLS-1$	27	String SCRIPT = "org.eclipse.wst.html.SCRIPT"; //$NON-NLS-1$
28	String SCRIPT_EVENTHANDLER = SCRIPT + ".EVENTHANDLER"; //$NON-NLS-1$	28	String SCRIPT_EVENTHANDLER = SCRIPT + ".EVENTHANDLER"; //$NON-NLS-1$
		29
		30	/**
		31	* @deprecated this partition type is not used locally any longer
		32	*/
29	String STYLE = "org.eclipse.wst.html.STYLE"; //$NON-NLS-1$	33	String STYLE = "org.eclipse.wst.html.STYLE"; //$NON-NLS-1$
30		34
31	// ISSUE: I think meta tag areas are here too?	35	// ISSUE: I think meta tag areas are here too?

Lines 210-215 Link Here

(-)plugin.xml (-1 / +67 lines)
210	description="%scope.structuredTextEditor.description"	210	description="%scope.structuredTextEditor.description"
211	id="org.eclipse.wst.sse.ui.structuredTextEditorScope">	211	id="org.eclipse.wst.sse.ui.structuredTextEditorScope">
212	</context>	212	</context>
		213	<context
		214	name="%scope.structuredTextEditor.comments.name"
		215	parentId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
		216	description="%scope.structuredTextEditor.comments.description"
		217	id="org.eclipse.wst.sse.comments">
		218	</context>
213	</extension>	219	</extension>
214	<!-- Keybindings for source editor -->	220	<!-- Keybindings for source editor -->
215	<extension point="org.eclipse.ui.bindings">	221	<extension point="org.eclipse.ui.bindings">
Lines 531-536 Link Here
531	id="quickFixProcessor"	537	id="quickFixProcessor"
532	name="%quickFixProcessor"	538	name="%quickFixProcessor"
533	schema="schema/quickFixProcessor.exsd"/>	539	schema="schema/quickFixProcessor.exsd"/>
		540	<extension-point id="commentingStrategy" name="%Commenting_Strategy_Extension.name" schema="schema/commentingStrategy.exsd"/>
534	<extension-point id="completionProposal" name="%Completion_Proposal.name" schema="schema/completionProposal.exsd"/>	541	<extension-point id="completionProposal" name="%Completion_Proposal.name" schema="schema/completionProposal.exsd"/>
535	<extension-point id="completionProposalCategoriesConfiguration" name="%Completion_Proposal_Categories_Configuration.name" schema="schema/completionProposalCategoriesConfiguration.exsd"/>	542	<extension-point id="completionProposalCategoriesConfiguration" name="%Completion_Proposal_Categories_Configuration.name" schema="schema/completionProposalCategoriesConfiguration.exsd"/>
536		543
Lines 661-668 Link Here
661	</command>	668	</command>
662	</menuContribution>	669	</menuContribution>
663		670
664	<menuContribution	671	<menuContribution
665	locationURI="popup:sourcePopupMenuId?after=sourceBegin">	672	locationURI="popup:sourcePopupMenuId?after=sourceBegin">
		673	<command
		674	commandId="org.eclipse.wst.sse.ui.toggle.comment"
		675	id="ToggleComment"
		676	style="push">
		677	<visibleWhen checkEnabled="false">
		678	<reference definitionId="org.eclipse.wst.sse.ui.commentingActiveContext.definition"></reference>
		679	</visibleWhen>
		680	</command>
		681	<command
		682	commandId="org.eclipse.wst.sse.ui.add.block.comment"
		683	id="AddBlockComment"
		684	style="push">
		685	<visibleWhen checkEnabled="false">
		686	<reference definitionId="org.eclipse.wst.sse.ui.commentingActiveContext.definition"></reference>
		687	</visibleWhen>
		688	</command>
		689	<command
		690	commandId="org.eclipse.wst.sse.ui.remove.block.comment"
		691	id="RemoveBlockComment"
		692	style="push">
		693	<visibleWhen checkEnabled="false">
		694	<reference definitionId="org.eclipse.wst.sse.ui.commentingActiveContext.definition"></reference>
		695	</visibleWhen>
		696	</command>
		697	<separator name="format" visible="true"></separator>
666	<command	698	<command
667	commandId="org.eclipse.wst.sse.ui.cleanup.document"	699	commandId="org.eclipse.wst.sse.ui.cleanup.document"
668	id="CleanupDocument"	700	id="CleanupDocument"
Lines 691-696 Link Here
691	</command>	723	</command>
692		724
693	</menuContribution>	725	</menuContribution>
		726	<menuContribution locationURI="menu:sourceMenuId?after=sourceBegin">
		727	<command commandId="org.eclipse.wst.sse.ui.toggle.comment"
		728	id="ToggleComment"
		729	mnemonic="%command.toggle.comment.mnemonic"
		730	style="push">
		731	<visibleWhen checkEnabled="false">
		732	<reference definitionId="org.eclipse.wst.sse.ui.commentingActiveContext.definition"/>
		733	</visibleWhen>
		734	</command>
		735	<command commandId="org.eclipse.wst.sse.ui.add.block.comment"
		736	id="AddBlockComment"
		737	mnemonic="%command.add.block.comment.mnemonic"
		738	style="push">
		739	<visibleWhen checkEnabled="false">
		740	<reference definitionId="org.eclipse.wst.sse.ui.commentingActiveContext.definition"/>
		741	</visibleWhen>
		742	</command>
		743	<command commandId="org.eclipse.wst.sse.ui.remove.block.comment"
		744	id="RemoveBlockComment"
		745	mnemonic="%command.remove.block.comment.mnemonic"
		746	style="push">
		747	<visibleWhen checkEnabled="false">
		748	<reference definitionId="org.eclipse.wst.sse.ui.commentingActiveContext.definition"/>
		749	</visibleWhen>
		750	</command>
		751	</menuContribution>
694	</extension>	752	</extension>
695	<extension	753	<extension
696	point="org.eclipse.ui.commands">	754	point="org.eclipse.ui.commands">
Lines 730-735 Link Here
730	</iterate>	788	</iterate>
731	</with>	789	</with>
732	</definition>	790	</definition>
		791	<definition
		792	id="org.eclipse.wst.sse.ui.commentingActiveContext.definition">
		793	<with variable="activeContexts">
		794	<iterate operator="or">
		795	<equals value="org.eclipse.wst.sse.comments"/>
		796	</iterate>
		797	</with>
		798	</definition>
733	</extension>	799	</extension>
734		800
735	<!-- Define theme -->	801	<!-- Define theme -->




Character_Pairing.name=Character Pairing Extension
Completion_Proposal.name=Completion Proposal
Completion_Proposal_Categories_Configuration.name=Completion Proposal Categories Configuration
Commenting_Strategy_Extension.name=Commenting Strategy Extension
##########################################################################
# These strings are used in Workbench Keys Preferences
##########################################################################
scope.structuredTextEditor.name=Editing in Structured Text Editors
scope.structuredTextEditor.description=Editing in Structured Text Editors
scope.structuredTextEditor.comments.description=Source Comments in Structured Text Editors
scope.structuredTextEditor.comments.name=Source Comments in Structured Text Editors
command.toggle.comment.name=Toggle Comment
command.toggle.comment.description=Toggle Comment
command.toggle.comment.mnemonic=T
command.add.block.comment.name=Add Block Comment
command.add.block.comment.description=Add Block Comment
command.add.block.comment.mnemonic=A
command.remove.block.comment.name=Remove Block Comment
command.remove.block.comment.description=Remove Block Comment
command.remove.block.comment.mnemonic=R
command.cleanup.document.name=Cleanup Document...
command.cleanup.document.description=Cleanup document
command.cleanup.document.mnemonic=C

Lines 189-194 Link Here

(-)src/org/eclipse/wst/sse/ui/StructuredTextEditor.java (-7 / +21 lines)
189	import org.eclipse.wst.sse.ui.internal.editor.SelectionConvertor;	189	import org.eclipse.wst.sse.ui.internal.editor.SelectionConvertor;
190	import org.eclipse.wst.sse.ui.internal.editor.StructuredModelDocumentProvider;	190	import org.eclipse.wst.sse.ui.internal.editor.StructuredModelDocumentProvider;
191	import org.eclipse.wst.sse.ui.internal.extension.BreakpointProviderBuilder;	191	import org.eclipse.wst.sse.ui.internal.extension.BreakpointProviderBuilder;
		192	import org.eclipse.wst.sse.ui.internal.handlers.AddBlockCommentHandler;
		193	import org.eclipse.wst.sse.ui.internal.handlers.RemoveBlockCommentHandler;
		194	import org.eclipse.wst.sse.ui.internal.handlers.ToggleLineCommentHandler;
192	import org.eclipse.wst.sse.ui.internal.hyperlink.OpenHyperlinkAction;	195	import org.eclipse.wst.sse.ui.internal.hyperlink.OpenHyperlinkAction;
193	import org.eclipse.wst.sse.ui.internal.preferences.EditorPreferenceNames;	196	import org.eclipse.wst.sse.ui.internal.preferences.EditorPreferenceNames;
194	import org.eclipse.wst.sse.ui.internal.projection.AbstractStructuredFoldingStrategy;	197	import org.eclipse.wst.sse.ui.internal.projection.AbstractStructuredFoldingStrategy;
Lines 1365-1378 Link Here
1365		1368
1366	computeAndSetDoubleClickAction();	1369	computeAndSetDoubleClickAction();
1367		1370
1368	IHandler handler = new GotoMatchingBracketHandler();	1371	//add handlers to handler service
1369	IHandlerService handlerService = (IHandlerService) getSite().getService(IHandlerService.class);	1372	IHandlerService handlerService = (IHandlerService) getSite().getService(IHandlerService.class);
1370	if (handlerService != null)	1373	if (handlerService != null) {
1371	handlerService.activateHandler(ActionDefinitionIds.GOTO_MATCHING_BRACKET, handler);	1374
1372	if (handlerService != null) {	1375	IHandler gotoHandler = new GotoMatchingBracketHandler();
1373	fOutlineHandler = new QuickOutlineHandler();	1376	handlerService.activateHandler(ActionDefinitionIds.GOTO_MATCHING_BRACKET, gotoHandler);
		1377
		1378	fOutlineHandler = new QuickOutlineHandler();
1374	handlerService.activateHandler(ActionDefinitionIds.SHOW_OUTLINE, fOutlineHandler);	1379	handlerService.activateHandler(ActionDefinitionIds.SHOW_OUTLINE, fOutlineHandler);
1375	}	1380
		1381	IHandler toggleCommentHandler = new ToggleLineCommentHandler();
		1382	handlerService.activateHandler(ActionDefinitionIds.TOGGLE_COMMENT, toggleCommentHandler);
		1383
		1384	IHandler addCommentBlockHandler = new AddBlockCommentHandler();
		1385	handlerService.activateHandler(ActionDefinitionIds.ADD_BLOCK_COMMENT, addCommentBlockHandler);
		1386
		1387	IHandler removeCommentBlockHandler = new RemoveBlockCommentHandler();
		1388	handlerService.activateHandler(ActionDefinitionIds.REMOVE_BLOCK_COMMENT, removeCommentBlockHandler);
		1389	}
1376		1390
1377	fShowPropertiesAction = new ShowPropertiesAction(getEditorPart(), getSelectionProvider());	1391	fShowPropertiesAction = new ShowPropertiesAction(getEditorPart(), getSelectionProvider());
1378	fFoldingGroup = new FoldingActionGroup(this, getSourceViewer());	1392	fFoldingGroup = new FoldingActionGroup(this, getSourceViewer());

Lines 90-95 Link Here

(-)src/org/eclipse/wst/sse/ui/internal/SSEUIMessages.java (+1 lines)
90	public static String ToggleComment_tooltip;	90	public static String ToggleComment_tooltip;
91	public static String ToggleComment_image;	91	public static String ToggleComment_image;
92	public static String ToggleComment_description;	92	public static String ToggleComment_description;
		93	public static String ToggleComment_progress;
93	public static String AddBlockComment_label;	94	public static String AddBlockComment_label;
94	public static String AddBlockComment_tooltip;	95	public static String AddBlockComment_tooltip;
95	public static String AddBlockComment_image;	96	public static String AddBlockComment_image;

Lines 62-67 Link Here

(-)src/org/eclipse/wst/sse/ui/internal/SSEUIPluginResources.properties (+1 lines)
62	ToggleComment_tooltip=Toggle Comment	62	ToggleComment_tooltip=Toggle Comment
63	ToggleComment_image=	63	ToggleComment_image=
64	ToggleComment_description=Toggle Comment	64	ToggleComment_description=Toggle Comment
		65	ToggleComment_progress=Toggling line comments...
65	AddBlockComment_label=Add &Block Comment	66	AddBlockComment_label=Add &Block Comment
66	AddBlockComment_tooltip=Add Block Comment	67	AddBlockComment_tooltip=Add Block Comment
67	AddBlockComment_image=	68	AddBlockComment_image=




/*******************************************************************************
 * Copyright (c) 2010 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
 *     
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.handlers;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.handlers.HandlerUtil;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;

/**
 * This class contains all of the shared functionality for comment handlers
 */
public abstract class AbstractCommentHandler extends AbstractHandler {

	/**
	 * <p>Default constructor must exist because sub classes are created by java reflection</p>
	 */
	public AbstractCommentHandler() {
		super();
	}

	/**
	 * <p>Gets the important information out of the event and passes it onto 
	 * the internal method {@link #processAction}</p>
	 * 
	 * @see org.eclipse.wst.xml.ui.internal.handlers.CommentHandler#execute(org.eclipse.core.commands.ExecutionEvent)
	 */
	public final Object execute(ExecutionEvent event) throws ExecutionException {
		IEditorPart editor = HandlerUtil.getActiveEditor(event);
		ITextEditor textEditor = null;
		if (editor instanceof ITextEditor)
			textEditor = (ITextEditor) editor;
		else {
			Object o = editor.getAdapter(ITextEditor.class);
			if (o != null)
				textEditor = (ITextEditor) o;
		}
		if (textEditor != null) {
			IDocument document = textEditor.getDocumentProvider().getDocument(textEditor.getEditorInput());
			if (document != null && document instanceof IStructuredDocument) {
				// get current text selection
				ITextSelection textSelection = getCurrentSelection(textEditor);
				if (!textSelection.isEmpty()) {
					//call the implementers code to deal with the event
					processAction(textEditor, (IStructuredDocument)document, textSelection);
				}
			}
		}
		return null;
	}

	/**
	 * <p>This method is called by the public {@link #execute} method whenever
	 * the comment handler is invoked.  This method should be used for the
	 * logic of handling the structured comment event.</p>
	 * 
	 * @param textEditor the text editor the initiating event was caused in
	 * @param document the document the text editor is editing
	 * @param textSelection the user selection when the event was caused
	 */
	protected abstract void processAction(ITextEditor textEditor, IStructuredDocument document, ITextSelection textSelection);
	
	/**
	 * <p>Gets the current user selection in the given {@link ITextEditor}</p>
	 * 
	 * @param textEditor get the user selection from here
	 * @return the current user selection in <code>textEdtior</code>
	 */
	private static ITextSelection getCurrentSelection(ITextEditor textEditor) {
		ISelectionProvider provider = textEditor.getSelectionProvider();
		if (provider != null) {
			ISelection selection = provider.getSelection();
			if (selection instanceof ITextSelection) {
				return (ITextSelection) selection;
			}
		}
		return TextSelection.emptySelection();
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.comment;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;

/**
 * <p>Represents a Line Comment commenting strategy</p>
 */
public class LineCommentingStrategy extends CommentingStrategy {
	/** the prefix of the line comment associated with this strategy */
	private String fPrefix;
	
	/**
	 * @param prefix the prefix of the line comment associated with this strategy
	 */
	public LineCommentingStrategy(String prefix) {
		super();
		this.fPrefix = prefix;
	}
	
	/**
	 * <p>Assumes that the given offset is at the begining of a line and adds the line
	 * comment prefix there</p>
	 * 
	 * @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#apply(
	 * 	org.eclipse.wst.sse.core.internal.provisional.IStructuredModel, int, int)
	 */
	public void apply(IStructuredDocument document, int offset, int length)
			throws BadLocationException {
		
		document.replace(offset, 0, this.fPrefix + " ");
	}

	/**
	 * <p>Assumes that the given offset is at the beginning of a line that is commented and removes
	 * the comment prefix from the beginning of the line, leading whitespace on the line will not
	 * prevent this method from finishing correctly</p>
	 * 
	 * @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#remove(
	 * 	org.eclipse.wst.sse.core.internal.provisional.IStructuredModel, int, int, boolean)
	 */
	public void remove(IStructuredDocument document, int offset, int length, boolean removeEnclosing) throws BadLocationException{
		String content = document.get(offset, length);
		int innerOffset = content.indexOf(this.fPrefix);
		if(innerOffset > 0) {
			offset += innerOffset;
		}
		
		uncomment(document, offset, this.fPrefix, -1,  null);
	}
	
	/**
	 * <p>A region is already commented if it begins with the the associated prefix ignoring any
	 * leading whitespace</p>
	 * 
	 * @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#alreadyCommenting(
	 * 	org.eclipse.jface.text.IDocument, org.eclipse.jface.text.IRegion)
	 */
	public boolean alreadyCommenting(IStructuredDocument document, IRegion region)
			throws BadLocationException {
		
		String regionContent = document.get(region.getOffset(), region.getLength()).trim();
		return regionContent.startsWith(this.fPrefix);
	}
	
	/**
	 * @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#clone()
	 */
	public Object clone() {
		return new LineCommentingStrategy(this.fPrefix);
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.handlers;

import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DocumentRewriteSession;
import org.eclipse.jface.text.DocumentRewriteSessionType;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentExtension4;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.Position;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.ui.StructuredTextEditor;
import org.eclipse.wst.sse.ui.internal.Logger;
import org.eclipse.wst.sse.ui.internal.SSEUIMessages;
import org.eclipse.wst.sse.ui.internal.StructuredTextViewer;
import org.eclipse.wst.sse.ui.internal.comment.BlockCommentingStrategy;
import org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy;
import org.eclipse.wst.sse.ui.internal.comment.CommentingStrategyRegistry;
import org.eclipse.wst.sse.ui.internal.comment.LineCommentingStrategy;

/**
 * <p>A comment handler to toggle line comments, this means that if a
 * comment already exists on a line then toggling it will remove the comment,
 * if the line in question is not already commented then it will not be commented.
 * If multiple lines are selected each will be commented separately.  The handler
 * first attempts to find a {@link LineCommentingStrategy} for a line, if it can
 * not find one then it will try and find a {@link BlockCommentingStrategy} to
 * wrap just that line in.</p>
 * 
 * <p>If a great number of lines are being toggled then a progress dialog will be
 * displayed because this can be a timely process</p>
 */
public final class ToggleLineCommentHandler extends AbstractCommentHandler {
	/** if toggling more then this many lines then use a busy indicator */
	private static final int TOGGLE_LINES_MAX_NO_BUSY_INDICATOR = 10;
	
	/**
	 * @see org.eclipse.wst.sse.ui.internal.handlers.AbstractCommentHandler#processAction(
	 * 	org.eclipse.ui.texteditor.ITextEditor, org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument,
	 * 	org.eclipse.jface.text.ITextSelection)
	 */
	protected void processAction(ITextEditor textEditor,
			final IStructuredDocument document, ITextSelection textSelection) {
		
		IStructuredModel model = null;
		DocumentRewriteSession session = null;
		boolean changed = false;
		
		try {
			// get text selection lines info
			int selectionStartLine = textSelection.getStartLine();
			int selectionEndLine = textSelection.getEndLine();
			
			int selectionEndLineOffset = document.getLineOffset(selectionEndLine);
			int selectionEndOffset = textSelection.getOffset() + textSelection.getLength();

			// adjust selection end line
			if ((selectionEndLine > selectionStartLine) && (selectionEndLineOffset == selectionEndOffset)) {
				selectionEndLine--;
			}

			// save the selection position since it will be changing
			Position selectionPosition = null;
			selectionPosition = new Position(textSelection.getOffset(), textSelection.getLength());
			document.addPosition(selectionPosition);

			
			model = StructuredModelManager.getModelManager().getModelForEdit(document);
			if (model != null) {
				//makes it so one undo will undo all the edits to the document
				model.beginRecording(this, SSEUIMessages.ToggleComment_label, SSEUIMessages.ToggleComment_description);
				
				//keeps listeners from doing anything until updates are all done
				model.aboutToChangeModel();
				if(document instanceof IDocumentExtension4) {
					session = ((IDocumentExtension4)document).startRewriteSession(DocumentRewriteSessionType.UNRESTRICTED);
				}
				changed = true;
				
				//get the display for the editor if we can
				Display display = null;
				if(textEditor instanceof StructuredTextEditor) {
					StructuredTextViewer viewer = ((StructuredTextEditor)textEditor).getTextViewer();
					if(viewer != null) {
						display = viewer.getControl().getDisplay();
					}
				}
				
				//create the toggling operation
				IRunnableWithProgress toggleCommentsRunnable = new ToggleLinesRunnable(
						model.getContentTypeIdentifier(), document, selectionStartLine, selectionEndLine, display);
				
				//if toggling lots of lines then use progress monitor else just run the operation
				if((selectionEndLine - selectionStartLine) > TOGGLE_LINES_MAX_NO_BUSY_INDICATOR && display != null) {
					ProgressMonitorDialog dialog = new ProgressMonitorDialog(display.getActiveShell());
					dialog.run(false, true, toggleCommentsRunnable);
				} else {
					toggleCommentsRunnable.run(new NullProgressMonitor());
				}
			}
		} catch (InvocationTargetException e) {
			Logger.logException("Problem running toggle comment progess dialog.", e);  //$NON-NLS-1$
		} catch (InterruptedException e) {
			Logger.logException("Problem running toggle comment progess dialog.", e);  //$NON-NLS-1$
		} catch (BadLocationException e) {
			Logger.logException("The given selection " + textSelection + " must be invalid", e); //$NON-NLS-1$ //$NON-NLS-2$
		} finally {
			//clean everything up
			if(session != null && document instanceof IDocumentExtension4) {
				((IDocumentExtension4)document).stopRewriteSession(session);
			}
			
			if(model != null) {
				model.endRecording(this);
				if(changed) {
					model.changedModel();
				}
				model.releaseFromEdit();
			}
		}
	}
	
	/**
	 * <p>The actual line toggling takes place in a runnable so it can be
	 * run as part of a progress dialog if there are many lines to toggle
	 * and thus the operation will take a noticeable amount of time the user
	 * should be aware of, this also allows for the operation to be canceled 
	 * by the user</p>
	 * 
	 */
	private static class ToggleLinesRunnable implements IRunnableWithProgress {
		/** the content type for the document being commented */
		private String fContentType;
		
		/** the document that the lines will be toggled on */
		private IStructuredDocument fDocument;
		
		/** the first line in the document to toggle */
		private int fSelectionStartLine;
		
		/** the last line in the document to toggle */
		private int fSelectionEndLine;
		
		/** the display, so that it can be updated during a long operation */
		private Display fDisplay;
		
		/**
		 * @param model {@link IStructuredModel} that the lines will be toggled on
		 * @param document {@link IDocument} that the lines will be toggled on
		 * @param selectionStartLine first line in the document to toggle
		 * @param selectionEndLine last line in the document to toggle
		 * @param display {@link Display}, so that it can be updated during a long operation
		 */
		protected ToggleLinesRunnable(String contentTypeIdentifier, IStructuredDocument document,
				int selectionStartLine, int selectionEndLine, Display display) {
			
			this.fContentType = contentTypeIdentifier;
			this.fDocument = document;
			this.fSelectionStartLine = selectionStartLine;
			this.fSelectionEndLine = selectionEndLine;
			this.fDisplay = display;
		}
		
		/**
		 * @see org.eclipse.jface.operation.IRunnableWithProgress#run(org.eclipse.core.runtime.IProgressMonitor)
		 */
		public void run(IProgressMonitor monitor) {
			//start work
			monitor.beginTask(SSEUIMessages.ToggleComment_progress,
					this.fSelectionEndLine-this.fSelectionStartLine);
			try {
				//toggle each line so long as task not canceled
				for (int line = this.fSelectionStartLine;
						line <= this.fSelectionEndLine && !monitor.isCanceled(); ++line) {
					
					//allows the user to be able to click the cancel button
					readAndDispatch(this.fDisplay);
					
					//get the line region
					IRegion lineRegion = this.fDocument.getLineInformation(line);
					
					//don't toggle empty lines
					String content = this.fDocument.get(lineRegion.getOffset(), lineRegion.getLength());
					if (content.trim().length() > 0) {
						//try to get a line comment type
						ITypedRegion[] lineTypedRegions =
							this.fDocument.computePartitioning(lineRegion.getOffset(), lineRegion.getLength());
						CommentingStrategy commentType = CommentingStrategyRegistry.getDefault().getLineCommentingStrategy(
								this.fContentType, lineTypedRegions);
						
						//could not find line comment type so find block comment type to use on line
						if(commentType == null) {
							commentType = CommentingStrategyRegistry.getDefault().getBlockCommentingStrategy(
									this.fContentType, lineTypedRegions);
						}
						
						//toggle the comment on the line
						if(commentType != null) {
							if(commentType.alreadyCommenting(this.fDocument, lineTypedRegions)) {
								commentType.remove(this.fDocument, lineRegion.getOffset(), lineRegion.getLength(), true);
							} else {
								commentType.apply(this.fDocument, lineRegion.getOffset(), lineRegion.getLength());
							}
						}
					}
					monitor.worked(1);
				}
			} catch(BadLocationException e) {
				Logger.logException("Bad location while toggling comments.", e);  //$NON-NLS-1$
			}
			//done work
			monitor.done();
		}
		
		/**
		 * <p>When calling {@link Display#readAndDispatch()} the game is off as to whose code you maybe
		 * calling into because of event handling/listeners/etc.  The only important thing is that
		 * the UI has been given a chance to react to user clicks.  Thus the logging of most {@link Exception}s
		 * and {@link Error}s as caused by {@link Display#readAndDispatch()} because they are not caused
		 * by this code and do not effect it.</p>
		 * 
		 * @param display the {@link Display} to call <code>readAndDispatch</code>
		 * on with exception/error handling.
		 */
		private void readAndDispatch(Display display) {
			try {
				display.readAndDispatch();
			}
			catch (Exception e) {
				Logger.log(Logger.WARNING,
						"Exception caused by readAndDispatch, not caused by or fatal to caller", e);
			}
			catch (LinkageError e) {
				Logger.log(Logger.WARNING,
						"LinkageError caused by readAndDispatch, not caused by or fatal to caller", e);
			}
			catch (VirtualMachineError e) {
				// re-throw these
				throw e;
			}
			catch (ThreadDeath e) {
				// re-throw these
				throw e;
			}
			catch (Error e) {
				// catch every error, except for a few that we don't want to handle
				Logger.log(Logger.WARNING,
						"Error caused by readAndDispatch, not caused by or fatal to caller", e);
			}
		}
	}
	
	/**
	 * @see org.eclipse.core.commands.AbstractHandler#isEnabled()
	 */
	public boolean isEnabled() {
		// TODO: IAN: fill this in
		return super.isEnabled();
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.handlers;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DocumentRewriteSession;
import org.eclipse.jface.text.DocumentRewriteSessionType;
import org.eclipse.jface.text.IDocumentExtension4;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.ui.internal.Logger;
import org.eclipse.wst.sse.ui.internal.SSEUIMessages;
import org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy;
import org.eclipse.wst.sse.ui.internal.comment.CommentingStrategyRegistry;

/**
 * <p>A comment handler to remove block comments</p>
 */
public final class RemoveBlockCommentHandler extends
		AbstractCommentHandler {

	/**
	 * @see org.eclipse.wst.sse.ui.internal.handlers.AbstractCommentHandler#processAction(org.eclipse.ui.texteditor.ITextEditor, org.eclipse.jface.text.IDocument, org.eclipse.jface.text.ITextSelection)
	 */
	protected void processAction(ITextEditor textEditor, IStructuredDocument document, ITextSelection textSelection) {
		
		IStructuredModel model = null;
		boolean changed = false;
		DocumentRewriteSession session = null;
		try {
			model = StructuredModelManager.getModelManager().getModelForEdit(document);
			
			if(model != null) {
				//makes it so one undo will undo all the edits to the document
				model.beginRecording(this, SSEUIMessages.RemoveBlockComment_label,
						SSEUIMessages.RemoveBlockComment_label);
				
				//keeps listeners from doing anything until updates are all done
				model.aboutToChangeModel();
				if(document instanceof IDocumentExtension4) {
					session = ((IDocumentExtension4)document).startRewriteSession(
							DocumentRewriteSessionType.UNRESTRICTED);
				}
				changed = true;
				
				ITypedRegion[] typedRegions = document.computePartitioning(
						textSelection.getOffset(), textSelection.getLength());
				CommentingStrategy commentType = CommentingStrategyRegistry.getDefault().getBlockCommentingStrategy(
						model.getContentTypeIdentifier(), typedRegions);
				
				if(commentType != null) {
					commentType.remove(document, textSelection.getOffset(), textSelection.getLength(), true);
				}
			}
		} catch (BadLocationException e) {
			Logger.logException("The given selection " + textSelection + " must be invalid", e); //$NON-NLS-1$ //$NON-NLS-2$
		} finally {
			//clean everything up
			if(session != null && document instanceof IDocumentExtension4) {
				((IDocumentExtension4)document).stopRewriteSession(session);
			}
			
			if(model != null) {
				model.endRecording(this);
				if(changed) {
					model.changedModel();
				}
				model.releaseFromEdit();
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.comment;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.ui.internal.Logger;

/**
 * <p>Defines a commenting strategy defined by the <code>org.eclipse.wst.sse.ui.commentinStrategy</code>
 * extension point and tracked by the {@link CommentingStrategyRegistry}.  Though it is important to
 * note it is note a one to one relationship of {@link CommentingStrategy}s to extensions, there is actually
 * one {@link CommentingStrategy} for each content type defined for each 
 * <code>org.eclipse.wst.sse.ui.commentinStrategy</code> extension.<p>
 * 
 * <p>The expected use case is that a {@link CommentingStrategy} is created off the basic configuration
 * of the extension point and then cloned for each associated content type and then each clone has
 * its partition information set using {@link #setPartitionInformation}.
 * Then the {@link CommentingStrategyRegistry} can be used to retrieve applicable {@link CommentingStrategy}s
 * and apply them to documents.</p>
 * 
 * <p>It is important to note that any instance of a {@link CommentingStrategy} is only valid for a specific
 * content type ID but this relationship is tracked by the {@link CommentingStrategyRegistry} and not by
 * the strategy itself.  Thus any reference to the strategy being valid for specific or general partition
 * types is implying it is already only valid for a specific content type</p>
 */
public abstract class CommentingStrategy {
	/** <code>true</code> if this strategy has any required partition types, <code>false</code> otherwise */
	private boolean fHasRequiredPartitionTypes;
	
	/** 
	 * <p><code>true</code> if for this strategy to be valid all of the required partition types must be seen,
	 * <code>false</code> if only at least one of the required partition types must be seen for this
	 * strategy to be valid.</p>
	 * 
	 * @see #fRequriedPartitionTypeIDs
	 */
	private boolean fRequireAllRequiredPartitionTypes;
	
	/**
	 * <p>required partition type IDs that must be seen for this strategy to be valid, the number of them
	 * that must be seen for the strategy to be valid is determined by {@link #fRequireAllRequiredPartitionTypes}
	 * this requirement is waved if the optional {@link #fAssociatedCommentPartitionTypeID} is specified and
	 * present because this strategy must be valid if its {@link #fAssociatedCommentPartitionTypeID} is present</p>
	 * 
	 * @see #fRequireAllRequiredPartitionTypes
	 * @see #fAssociatedCommentPartitionTypeID
	 */
	private List fRequriedPartitionTypeIDs;
	
	/**
	 * <p>if <code>true</code> then {@link #fAllowablePartitionTypeIDs} is ignored because
	 * this strategy is valid for any partition type, if <code>false</code> then this
	 * strategy is only valid for those partition types listed in {@link #fAllowablePartitionTypeIDs}</p>
	 * 
	 * @see #fAllowablePartitionTypeIDs
	 */
	private boolean fAllPartitionTypesAllowable;
	
	/**
	 * <p>the partition types that this strategy is valid for, it is also automatically valid for
	 * any partition types listed in {@link #fRequriedPartitionTypeIDs} and the optionally
	 * specified {@link #fAssociatedCommentPartitionTypeID}</p>
	 * 
	 * @see #fAllPartitionTypesAllowable
	 * @see #fRequriedPartitionTypeIDs
	 * @see #fAssociatedCommentPartitionTypeID
	 */
	private List fAllowablePartitionTypeIDs;
	
	/**
	 * an optional associated comment partition type ID, if this partition type is seen then the
	 * the {@link #fRequriedPartitionTypeIDs} requirement is waved as to weather this strategy is
	 * valid or not
	 * 
	 * @see #fRequriedPartitionTypeIDs
	 */
	private String fAssociatedCommentPartitionTypeID;
	
	/**
	 * <p>Default constructor, the specific initialization is done by
	 * {@link #setPartitionInformation}</p>
	 */
	public CommentingStrategy() {
		this.fAssociatedCommentPartitionTypeID = null;
		this.fRequriedPartitionTypeIDs = Collections.EMPTY_LIST;
		this.fAllowablePartitionTypeIDs = Collections.EMPTY_LIST;
		this.fHasRequiredPartitionTypes = false;
		this.fRequireAllRequiredPartitionTypes = false;
		this.fAllPartitionTypesAllowable = false;
	}
	
	/**
	 * <p>Used to set up the partition information for this strategy</p>
	 * <p>This information is used to determine if a strategy is valid for a set of
	 * {@link ITypedRegion}s.</p>
	 * 
	 * @param allowablePartitionTypeIDs the partition types this strategy is valid for, the strategy will also
	 * be considered valid for any of the required partition types
	 * @param allPartitionTypesAllowable if <code>true</code> then this strategy is valid for any partition types
	 * thus ignoring the <code>allowablePartitionTypeIDs</code>, <code>false</code> otherwise
	 * @param requiredPartitionTypeIDs partition type IDs that must be seen for this strategy to be valid, there
	 * are exceptions to this rule, see {@link #isApplicableFor(ITypedRegion[])}
	 * @param requireAllRequiredPartitionTypes <code>true</code> if all of the <code>requiredPartitionTypeIDs must
	 * be seen for this strategy to be valid, <code>false</code> otherwise, there are exceptions to these rules, see
	 * {@link #isApplicableFor(ITypedRegion[])}
	 * @param associatedCommentPartitionTypeID optional comment partition type associated with this strategy,
	 * maybe <code>null</code>
	 * 
	 * @see #isApplicableFor(ITypedRegion[])
	 */
	protected final void setPartitionInformation(List allowablePartitionTypeIDs, boolean allPartitionTypesAllowable,
			List requiredPartitionTypeIDs, boolean requireAllRequiredPartitionTypes, String associatedCommentPartitionTypeID) {
		
		this.fAllPartitionTypesAllowable = allPartitionTypesAllowable;
		this.fRequireAllRequiredPartitionTypes = requireAllRequiredPartitionTypes;
		
		this.fRequriedPartitionTypeIDs = requiredPartitionTypeIDs;
		if(this.fRequriedPartitionTypeIDs == null) {
			this.fRequriedPartitionTypeIDs = Collections.EMPTY_LIST;
		}
		
		this.fHasRequiredPartitionTypes = this.fRequriedPartitionTypeIDs.size() != 0;
		
		this.fAllowablePartitionTypeIDs = allowablePartitionTypeIDs;
		if(this.fAllowablePartitionTypeIDs == null) {
			this.fAllowablePartitionTypeIDs = Collections.EMPTY_LIST;
		}
		
		this.fAssociatedCommentPartitionTypeID = associatedCommentPartitionTypeID;
	}
	
	/**
	 * <p>Applies this strategy to the given model starting at the given offset for the given length</p>
	 * 
	 * @param document {@link IStructuredDocument} to apply this strategy too
	 * @param offset the offset to start this comment at
	 * @param length the length of the region to apply this comment too
	 * 
	 * @throws BadLocationException it is not the fault of the strategy if callers passes a bad
	 * <code>offset</code> and/or <code>length</code> for the given <code>model</code>
	 */
	public abstract void apply(IStructuredDocument document, int offset, int length) throws BadLocationException;
	
	/**
	 * <p>Remove any comments associated with this strategy from the given model for the given offset to
	 * the given length.  Weather a comment surrounding the given range should be removed can also be
	 * specified</p>
	 * 
	 * @param document {@link IStructuredDocument} to remove comments associated with this strategy from
	 * @param offset the location to start removing comments associated with this strategy from
	 * @param length the length of the region to remove associated comments from
	 * @param removeEnclosing weather a comment should be removed if it incloses the region specified
	 * by the given <code>offset</code> and <code>length</code>
	 * 
	 * @throws BadLocationException it is not the fault of the strategy if callers passes a bad
	 * <code>offset</code> and/or <code>length</code> for the given <code>model</code>
	 */
	public abstract void remove(IStructuredDocument document, int offset, int length, boolean removeEnclosing) throws BadLocationException;
	
	/**
	 * <p>Determines if the given region is a comment region commented by this strategy.</p>
	 * 
	 * @param document {@link IStructuredDocument} containing the given <code>region</code>
	 * @param region determine if this region is a comment region commented by this strategy
	 * @return <code>true</code> if the given <code>region</code> has already been
	 * commented by this strategy, <code>false</code> otherwise
	 * 
	 * @throws BadLocationException it is not the fault of the strategy if callers passes a bad
	 * <code>offset</code> and/or <code>length</code> for the given <code>model</code>
	 */
	public abstract boolean alreadyCommenting(IStructuredDocument document, IRegion region) throws BadLocationException;
	
	/** 
	 * <p>Implementers should return a copy of themselves</p>
	 * <p>Allows the {@link CommentingStrategyRegistry} to create a {@link CommentingStrategy} for
	 * each of its associated content types.</p>
	 * 
	 * @return implementers should return an object of type {@link CommentingStrategy}
	 * 
	 * @see java.lang.Object#clone()
	 */
	public abstract Object clone();
	
	/**
	 * <p>Determines if this strategy is applicable for the given regions for either commenting or un-commenting. 
	 * For this strategy to be applicable the given regions must contain at least one or all of the
	 * {@link #fRequriedPartitionTypeIDs} (depending on the value of {@link #fRequireAllRequiredPartitionTypes})
	 * or contain at least one region of type {@link #fAssociatedCommentPartitionTypeID}.  Also if the value of
	 * {@link #fAllPartitionTypesAllowable} is <code>false</code> the given regions must all be of type
	 * {@link #fAllowablePartitionTypeIDs} and/or {@link #fRequriedPartitionTypeIDs} and/or
	 * {@link #fAssociatedCommentPartitionTypeID} otherwise the regions can be of any type except for they still
	 * must beet the required partition type requirements</p>
	 * 
	 * @param regions determine if this strategy is applicable for these regions
	 * @return <code>true</code> if this strategy is applicable for the given <code>regions</code>
	 * <code>false</code> otherwise.
	 */
	public final boolean isApplicableFor(ITypedRegion[] regions) {
		List partitionTypeIDs = getPartitionTypeIDs(regions);
		
		boolean foundAssociatedCommentPartitions = false;
		if(this.fAssociatedCommentPartitionTypeID != null) {
			foundAssociatedCommentPartitions = partitionTypeIDs.contains(this.fAssociatedCommentPartitionTypeID);
			if(foundAssociatedCommentPartitions) {
				//remove all instances of the comment partition type
				boolean removed;
				do {
					removed = partitionTypeIDs.remove(this.fAssociatedCommentPartitionTypeID);
				} while(removed);
			}
		}
		
		//determine if required partitions requirements are met
		boolean requiredPartitionsRequirementsMet = false;
		if(this.fHasRequiredPartitionTypes) {
			/* either all specified required partitions must be found,
			 * or just at least one of them must be found
			 */
			if(this.fRequireAllRequiredPartitionTypes) {
				requiredPartitionsRequirementsMet =
					partitionTypeIDs.containsAll(this.fRequriedPartitionTypeIDs);
				partitionTypeIDs.removeAll(this.fRequriedPartitionTypeIDs);
			} else {
				requiredPartitionsRequirementsMet =
					partitionTypeIDs.removeAll(this.fRequriedPartitionTypeIDs);
			}
		} else {
			requiredPartitionsRequirementsMet = true;
		}
		
		//determine if allowable partitions requirements are met
		boolean allowablePartitionsRequirementsMet = false;
		if(this.fAllPartitionTypesAllowable) {
			allowablePartitionsRequirementsMet = true;
		} else {
			partitionTypeIDs.removeAll(this.fAllowablePartitionTypeIDs);
			
			//at this point all required partitions and allowable partitions have been removed
			allowablePartitionsRequirementsMet = partitionTypeIDs.size() == 0;
		}
		
		return (requiredPartitionsRequirementsMet || foundAssociatedCommentPartitions) && allowablePartitionsRequirementsMet;
	}
	
	/**
	 * <p>Convenience method to take a list of regions and create one encompassing region to pass to
	 * {@link #alreadyCommenting(IDocument, IRegion)}</p>
	 * 
	 * @param document {@link IDocument} that contains the given <code>regions</code>
	 * @param regions {@link IRegion}s to combine into one region and pass onto
	 * {@link #alreadyCommenting(IDocument, IRegion)}
	 * 
	 * @return the result of a call to {@link #alreadyCommenting(IDocument, IRegion)} combining
	 * all of the given <code>regions</code> into one region
	 * 
	 * @throws BadLocationException it is not the fault of the strategy if callers passes a bad
	 * <code>offset</code> and/or <code>length</code> for the given <code>model</code>
	 */
	public final boolean alreadyCommenting(IStructuredDocument document, IRegion[] regions) throws BadLocationException {
		boolean alreadyCommenting = false;
		if(regions != null && regions.length > 0) {
			//create one region spanning all the given regions
			int offset = regions[0].getOffset();
			int length = regions[regions.length-1].getOffset() +
					regions[regions.length-1].getLength() - offset;
		
			IRegion region = new Region(offset, length);
			alreadyCommenting = this.alreadyCommenting(document, region);
		}
		
		return alreadyCommenting;
	}
	/**
	 * <p>Given a list of {@link ITypedRegion}s returns the sub set of that list that
	 * are of the comment region type associated with this strategy</p>
	 * 
	 * @param typedRegions {@link ITypedRegion}s to filter down to only the comment regions
	 * associated with this strategy
	 * 
	 * @return {@link List} of {@link ITypedRegion}s from the given <code>typedRegions</code>
	 * that are of the comment partition type associated with this strategy
	 */
	protected List getAssociatedCommentedRegions(ITypedRegion[] typedRegions) {
		List commentedRegions = new ArrayList();
		
		for(int i = 0; i < typedRegions.length; ++i) {
			if(typedRegions[i].getType().equals(this.fAssociatedCommentPartitionTypeID)) {
				commentedRegions.add(typedRegions[i]);
			}
		}
		
		return commentedRegions;
	}
	
	/**
	 * <p>Given a list of {@link ITypedRegion}s returns a list of the partition
	 * type IDs taken from the given regions.</p>
	 * 
	 * @param regions {@link ITypedRegion}s to get the partition type IDs from
	 * @return {@link List} of the partition type IDs taken from the given <code>regions</code>
	 */
	private static List getPartitionTypeIDs(ITypedRegion[] regions) {
		List partitionTypes = new ArrayList(regions.length);
		for(int i = 0; i < regions.length; ++i) {
			partitionTypes.add(regions[i].getType());
		}
		
		return partitionTypes;
	}
	
	/**
	 * <p>This method modifies the given document to remove the given comment
	 * prefix at the given comment prefix offset and the given comment
	 * suffix at the given comment suffix offset.  In the case of removing
	 * a line comment that does not have a suffix, pass <code>null</code>
	 * for the comment suffix and it and its associated offset will
	 * be ignored.</p>
	 * 
	 * <p><b>NOTE:</b> it is a good idea if a model is at hand when calling this to
	 * warn the model of an impending update</p>
	 * 
	 * @param document the document to remove the comment from
	 * @param commentPrefixOffset the offset of the comment prefix
	 * @param commentSuffixOffset the offset of the comment suffix
	 * (ignored if <code>commentSuffix</code> is <code>null</code>)
	 * @param commentPrefix the prefix of the comment to remove from its associated given offset
	 * @param commentSuffix the suffix of the comment to remove from its associated given offset,
	 * or null if there is not suffix to remove for this comment
	 */
	protected static void uncomment(IDocument document, int commentPrefixOffset, String commentPrefix,
			int commentSuffixOffset,  String commentSuffix) {
		
		try {
			//determine if there is a space after the comment prefix that should also be removed
			int commentPrefixLength = commentPrefix.length();
			String postCommentPrefixChar = document.get(commentPrefixOffset + commentPrefix.length(), 1);
			if(postCommentPrefixChar.equals(" ")) {
				commentPrefixLength++;
			}
			
			//remove the comment prefix
			document.replace(commentPrefixOffset, commentPrefixLength, ""); //$NON-NLS-1$
			
			if(commentSuffix != null) {
				commentSuffixOffset -= commentPrefixLength;
				
				//determine if there is a space before the comment suffix that should also be removed
				int commentSuffixLength = commentSuffix.length();
				String preCommentSuffixChar = document.get(commentSuffixOffset-1, 1);
				if(preCommentSuffixChar.equals(" ")) {
					commentSuffixLength++;
					commentSuffixOffset--;
				}
				
				//remove the comment suffix
				document.replace(commentSuffixOffset, commentSuffixLength, ""); //$NON-NLS-1$
			}
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.handlers;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DocumentRewriteSession;
import org.eclipse.jface.text.DocumentRewriteSessionType;
import org.eclipse.jface.text.IDocumentExtension4;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.Logger;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.ui.internal.SSEUIMessages;
import org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy;
import org.eclipse.wst.sse.ui.internal.comment.CommentingStrategyRegistry;

/**
 * <p>A comment handler to add block comments</p>
 */
public final class AddBlockCommentHandler extends
		AbstractCommentHandler {

	/**
	 * @see org.eclipse.wst.sse.ui.internal.handlers.AbstractCommentHandler#processAction(
	 * 	org.eclipse.ui.texteditor.ITextEditor, org.eclipse.jface.text.IDocument, org.eclipse.jface.text.ITextSelection)
	 */
	protected void processAction(ITextEditor textEditor, IStructuredDocument document, ITextSelection textSelection) {
		IStructuredModel model = null;
		boolean changed = false;
		DocumentRewriteSession session = null;
		
		try {
			model = StructuredModelManager.getModelManager().getModelForEdit(document);
			if(model != null) {
				//makes it so one undo will undo all the edits to the document
				model.beginRecording(this, SSEUIMessages.AddBlockComment_label, SSEUIMessages.AddBlockComment_description);
				
				//keeps listeners from doing anything until updates are all done
				model.aboutToChangeModel();
				if(document instanceof IDocumentExtension4) {
					session = ((IDocumentExtension4)document).startRewriteSession(DocumentRewriteSessionType.UNRESTRICTED);
				}
				changed = true;
				
				ITypedRegion[] typedRegions = document.computePartitioning(textSelection.getOffset(), textSelection.getLength());
				CommentingStrategy commentType = CommentingStrategyRegistry.getDefault().getBlockCommentingStrategy(model.getContentTypeIdentifier(), typedRegions);
				
				if(commentType != null) {
					commentType.apply(document, textSelection.getOffset(), textSelection.getLength());
				}
			}
		} catch (BadLocationException e) {
			Logger.logException("The given selection " + textSelection + " must be invalid", e); //$NON-NLS-1$ //$NON-NLS-2$
		} finally {
			//clean everything up
			if(session != null && document instanceof IDocumentExtension4) {
				((IDocumentExtension4)document).stopRewriteSession(session);
			}
			
			if(model != null) {
				model.endRecording(this);
				if(changed) {
					model.changedModel();
				}
				model.releaseFromEdit();
			}
		}
	}
}




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.wst.sse.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.wst.sse.ui" id="commentingStrategy" name="Commenting Strategy"/>
      </appInfo>
      <documentation>
         This extension point allows the contribution of commenting strategy&apos;s to participate in the commenting actions, such as adding and removing commenting blocks and toggling line comments.
      </documentation>
   </annotation>

   <element name="extension">
      <annotation>
         <appInfo>
            <meta.element />
         </appInfo>
      </annotation>
      <complexType>
         <sequence>
            <choice minOccurs="1" maxOccurs="unbounded">
               <element ref="blockCommentingStrategy" minOccurs="0" maxOccurs="unbounded"/>
               <element ref="lineCommentingStrategy" minOccurs="0" maxOccurs="unbounded"/>
            </choice>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  an optional identifier of the extension instance
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="blockCommentingStrategy">
      <annotation>
         <documentation>
            Defines a block commenting strategy
         </documentation>
      </annotation>
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="contentType"/>
         </sequence>
         <attribute name="prefix" type="string" use="required">
            <annotation>
               <documentation>
                  The prefix of the block comment this strategy impliments
               </documentation>
            </annotation>
         </attribute>
         <attribute name="suffix" type="string" use="required">
            <annotation>
               <documentation>
                  The suffix of the block comment this strategy impliments
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="lineCommentingStrategy">
      <annotation>
         <documentation>
            Deefines a line commenting strategy
         </documentation>
      </annotation>
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="contentType"/>
         </sequence>
         <attribute name="prefix" type="string" use="required">
            <annotation>
               <documentation>
                  The prefix of the block comment this strategy impliments
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="contentType">
      <annotation>
         <documentation>
            A content type that the strategy is applicable for
         </documentation>
      </annotation>
      <complexType>
         <sequence>
            <choice>
               <element ref="requiredPartitionTypes"/>
               <element ref="allowablePartitionTypes"/>
               <sequence>
                  <element ref="requiredPartitionTypes"/>
                  <element ref="allowablePartitionTypes"/>
               </sequence>
            </choice>
         </sequence>
         <attribute name="id" type="string" use="required">
            <annotation>
               <documentation>
                  The ID of the content type
               </documentation>
               <appInfo>
                  <meta.attribute kind="identifier" basedOn="org.eclipse.core.contenttype.contentTypes/content-type/@id"/>
               </appInfo>
            </annotation>
         </attribute>
         <attribute name="associatedCommentPartitionTypeID" type="string">
            <annotation>
               <documentation>
                  The partition type ID of the comment partition that is associated with the strategy in this content type
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="requiredPartitionTypes">
      <annotation>
         <documentation>
            List of partition types in the associated content type that are requried for the strategy to be applicable.  Depending on the value of the &lt;code&gt;requireAll&lt;/code&gt; attribute either all or only at least one of these partition types must be present in a selection for the strategy to be applicable.
         </documentation>
      </annotation>
      <complexType>
         <sequence minOccurs="1" maxOccurs="unbounded">
            <element ref="partitionType"/>
         </sequence>
         <attribute name="requireAll" type="boolean" use="default" value="false">
            <annotation>
               <documentation>
                  If &lt;code&gt;true&lt;/code&gt; then all of the required partition types must be present in a user selection for the strategy to be valid, if &lt;code&gt;false&lt;/code&gt; only at least one of the required partition types must be present in the a user selection for the strategy to be valid.  These conditions are shortucted if the &lt;code&gt;associatedCommentPartitiontTypeID&lt;/code&gt; for the &lt;code&gt;contentType&lt;/code&gt; that thes required partition types are associated with is present in the user selection
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="allowablePartitionTypes">
      <annotation>
         <documentation>
            The partition types that are allowed in a user selection for the strategy to be valid.  It is assumed that any partition types listed in the &lt;code&gt;requiredPartitionTypes&lt;/code&gt; are also allowable.  This list is ignored if the value of &lt;code&gt;anyPartitionType&lt;/code&gt; is &lt;code&gt;true&lt;/code&gt;.  If this list is not provided then it is assumed the value of &lt;code&gt;anyPartitionType&lt;/code&gt; is false.
         </documentation>
      </annotation>
      <complexType>
         <sequence minOccurs="0" maxOccurs="unbounded">
            <element ref="partitionType"/>
         </sequence>
         <attribute name="anyPartitionType" type="boolean" use="default" value="false">
            <annotation>
               <documentation>
                  If &lt;code&gt;true&lt;/code&gt; then the strategy is valid for any partition type in the associated &lt;code&gt;contentType&lt;/code&gt;, this means that any &lt;code&gt;partionType&lt;/code&gt;s listed here would be ignored.  If &lt;code&gt;false&lt;/code&gt; then only the &lt;code&gt;partitionType&lt;/code&gt;s listed here are allowed in a user selection (allong with any specified requried partition types) for the strategy to be valid.
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="partitionType">
      <annotation>
         <documentation>
            A partition type associated with the parenting content type
         </documentation>
      </annotation>
      <complexType>
         <attribute name="id" type="string" use="required">
            <annotation>
               <documentation>
                  The ID of the partition type.
               </documentation>
            </annotation>
         </attribute>
      </complexType>
   </element>


   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         &lt;p&gt;&lt;b&gt;Example 1:&lt;/b&gt; A simple example for block comments on XML documents&lt;/p&gt;&lt;pre&gt;&lt;extension point=&quot;org.eclipse.wst.sse.ui.commentingStrategy&quot;&gt;
  &lt;blockCommentingStrategy
      prefix=&quot;&amp;lt;!--&quot;
      suffix=&quot;--&amp;gt;&quot;&gt;
    &lt;contentType
        id=&quot;org.eclipse.core.runtime.xml&quot;
        associatedCommentPartitionTypeID=&quot;org.eclipse.wst.xml.XML_COMMENT&quot;&gt;
      &lt;allowablePartitionTypes
          anyPartitionType=&quot;true&quot;&gt;
      &lt;/allowablePartitionTypes&gt;
    &lt;/contentType&gt;
  &lt;/blockCommentingStrategy&gt;
&lt;/extension&gt;&lt;/pre&gt;

&lt;p&gt;&lt;b&gt;Example 2:&lt;/b&gt; A more complex example for adding CSS comenting to both CSS and HTML documents&lt;/p&gt;&lt;pre&gt;&lt;extension point=&quot;org.eclipse.wst.sse.ui.commentingStrategy&quot;&gt;
  &lt;blockCommentingStrategy
      prefix=&quot;/*&quot;
      suffix=&quot;*/&quot;&gt;
    &lt;contentType
        associatedCommentPartitionTypeID=&quot;org.eclipse.wst.css.COMMENT&quot;
        id=&quot;org.eclipse.wst.css.core.csssource&quot;&gt;
      &lt;allowablePartitionTypes
          anyPartitionType=&quot;true&quot;&gt;
      &lt;/allowablePartitionTypes&gt;
    &lt;/contentType&gt;
    &lt;contentType
        id=&quot;org.eclipse.wst.html.core.htmlsource&quot;&gt;
      &lt;allowablePartitionTypes
          anyPartitionType=&quot;false&quot;&gt;
      &lt;/allowablePartitionTypes&gt;
      &lt;requiredPartitionTypes
          requireAll=&quot;true&quot;&gt;
        &lt;partitionType
            id=&quot;org.eclipse.wst.css.STYLE&quot;&gt;
        &lt;/partitionType&gt;
      &lt;/requiredPartitionTypes&gt;
    &lt;/contentType&gt;
  &lt;/blockCommentingStrategy&gt;
&lt;/extension&gt;&lt;/pre&gt;
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiinfo"/>
      </appInfo>
      <documentation>
         The user of this extension point does not need to impliment any classes themselves but for their contributions to work in any given content type then the following handlers must be registered for the content type in question by using the &lt;code&gt;org.eclipse.ui.handlers&lt;/code&gt; extension point.
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;org.eclipse.wst.sse.ui.handlers.AddBlockCommentHandler&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;org.eclipse.wst.sse.ui.handlers.RemoveBlockCommentHandler&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;org.eclipse.wst.sse.ui.handlers.ToggleLineCommentHandler&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
      </documentation>
   </annotation>


   <annotation>
      <appInfo>
         <meta.section type="copyright"/>
      </appInfo>
      <documentation>
         Copyright (c) 2010 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 &lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
      </documentation>
   </annotation>

</schema>




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.comment;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.InvalidRegistryObjectException;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.wst.sse.ui.internal.Logger;
import org.eclipse.wst.sse.ui.internal.SSEUIPlugin;

/**
 * <p>The registry of {@link CommentingStrategy}s defined by the <code>org.eclipse.wst.sse.ui.commentinStrategy</code>
 * extension point.</p>
 */
public class CommentingStrategyRegistry {
	/** The extension schema name of the extension point */
	private static final String EXTENSION_POINT = "commentingStrategy"; //$NON-NLS-1$
	
	/** The extension schema name of proposal block comment child elements. */
	private static final String ELEM_PROPOSAL_BLOCK_COMMENTING_STRATEGY = "blockCommentingStrategy"; //$NON-NLS-1$
	
	/** The extension schema name of proposal line comment child elements. */
	private static final String ELEM_PROPOSAL_LINE_COMMENTING_STRATEGY = "lineCommentingStrategy"; //$NON-NLS-1$
	
	/** The extension schema name of the content type child elements. */
	private static final String ELEM_CONTENT_TYPE = "contentType"; //$NON-NLS-1$
	
	/** The extension schema name of the required partition types child elements */
	private static final String ELEM_REQUIRED_PARTITION_TYPES= "requiredPartitionTypes"; //$NON-NLS-1$
	
	/** The extension schema name of the allowable partition types child elements */
	private static final String ELEM_ALLOWABLE_PARTITION_TYPES= "allowablePartitionTypes"; //$NON-NLS-1$
	
	/** The extension schema name of partition type child elements */
	private static final String ELEM_PARTITION_TYPE= "partitionType"; //$NON-NLS-1$
	
	/** The extension schema name of the prefix attribute */
	private static final String ATTR_PREFIX = "prefix"; //$NON-NLS-1$
	
	/** The extension schema name of the suffix attribute */
	private static final String ATTR_SUFFIX = "suffix"; //$NON-NLS-1$
	
	/** The extension schema name of the associatedCommentPartitionTypeID attribute */
	private static final String ATTR_ASSOCIATED_COMMENT_PARTITION_TPYPE_ID = "associatedCommentPartitionTypeID"; //$NON-NLS-1$
	
	/** The extension schema name of the anyPartitionType attribute */
	private static final String ATTR_ANY_PARTITION_TYPE = "anyPartitionType";  //$NON-NLS-1$
	
	/** The extension schema name of the requireAll attribute */
	private static final String ATTR_REQUIRE_ALL = "requireAll"; //$NON-NLS-1$
	
	/** The extension schema name for ID attribute */
	private static final String ATTR_ID= "id"; //$NON-NLS-1$
	
	/** the singleton instance of the registry */
	private static CommentingStrategyRegistry fSingleton = null;
	
	/** <code>true</code> if this registry has been loaded. */
	private boolean fLoaded;
	
	/**
	 * <p>Registry of content type IDs to {@link BlockCommentingStrategy}s</p>
	 * 
	 * <code>{@link Map}&lt{@link String}, {@link List}&lt{@link BlockContentType}&gt&gt</code>
	 * <ul>
	 * <li><b>key:</b> content type ID</li>
	 * <li><b>value:</b> {@link List} of associated {@link BlockContentType}s</li>
	 * <ul>
	 */
	private Map fBlockCommentTypes;
	
	/**
	 * <p>Registry of content type IDs to {@link LineCommentingStrategy}s</p>
	 *
	 * <code>{@link Map}&lt{@link String}, {@link List}&lt{@link LineContentType}&gt&gt</code>
	 * <ul>
	 * <li><b>key:</b> content type ID</li>
	 * <li><b>value:</b> {@link List} of associated {@link LineContentType}s</li>
	 * <ul>
	 */
	private Map fLineCommentTypes;
	
	/**
	 * @return the single instance of the {@link CommentingStrategyRegistry}
	 */
	public static synchronized CommentingStrategyRegistry getDefault() {
		if(fSingleton == null) {
			fSingleton = new CommentingStrategyRegistry();
		}
		
		return fSingleton;
	}
	
	/**
	 * Singleton constructor for the registry
	 */
	private CommentingStrategyRegistry() {
		this.fLoaded = false;
		this.fBlockCommentTypes = new HashMap();
		this.fLineCommentTypes = new HashMap();
	}
	
	/**
	 * @param contentTypeID get only {@link BlockCommentingStrategy}s associated with this content type
	 * @param regions get only {@link BlockCommentingStrategy}s associated with these types of regions
	 * @return all the {@link BlockCommentingStrategy}s associated with the given content type and regions
	 */
	public CommentingStrategy getBlockCommentingStrategy(String contentTypeID, ITypedRegion[] regions) {
		return getCommentingStrategy(contentTypeID, regions, this.fBlockCommentTypes);
	}
	
	/**
	 * @param contentTypeID get only {@link LineCommentingStrategy}s associated with this content type
	 * @param regions get only {@link LineCommentingStrategy}s associated with these types of regions
	 * @return all the {@link LineCommentingStrategy}s associated with the given content type and regions
	 */
	public CommentingStrategy getLineCommentingStrategy(String contentTypeID, ITypedRegion[] regions) {
		return getCommentingStrategy(contentTypeID, regions, this.fLineCommentTypes);
	}
	
	/**
	 * <p>get all the {@link CommentingStrategy}s associated with the given content type and regions
	 * from the given registry</p>
	 * 
	 * @param contentTypeID  get only {@link CommentingStrategy}s associated with this content type
	 * @param regions get only {@link CommentingStrategy}s associated with these types of regions
	 * @param registry get the {@link CommentingStrategy}s from this registry
	 * @return all the {@link CommentingStrategy}s associated with the given content type and regions
	 * from the given registry
	 */
	private CommentingStrategy getCommentingStrategy(String contentTypeID, ITypedRegion[] regions, Map registry) {
		ensureExtensionPointRead();
		
		CommentingStrategy match = null;
		IContentType contentType = Platform.getContentTypeManager().getContentType(contentTypeID);
		
		/* get all the commenting strategies for the given content type id,
		 * including those registered for parent content types
		 */
		List possibleCommentingStrategies = new ArrayList();
		while(contentType != null) {
			List contentTypeCommentingStrategies = (List)registry.get(contentType.getId());
			if(contentTypeCommentingStrategies != null && contentTypeCommentingStrategies.size() > 0) {
				possibleCommentingStrategies.addAll(contentTypeCommentingStrategies);
			}
			contentType = contentType.getBaseType();
		}
		
		/* find the commenting strategy applicable for the given regions,
		 * because strategies were added starting from the most specific
		 * content type first, the most specific strategy will always be chosen
		 */
		for(int i = 0; i < possibleCommentingStrategies.size() && match == null; ++i) {
			CommentingStrategy commentType = (CommentingStrategy)possibleCommentingStrategies.get(i);
			if(commentType.isApplicableFor(regions)) {
				match = commentType;
			}
		}
		
		return match;
	}
	
	/**
	 * <p>Ensures that the extensions are read and this registry is built</p>
	 */
	private void ensureExtensionPointRead() {
		if(!fLoaded) {
			load();
			fLoaded = true;
		}
	}
	
	/**
	 * <p>Load the extension points into the registry</p>
	 */
	private void load() {
		IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry();
		List extensionElements = new ArrayList(Arrays.asList(extensionRegistry.getConfigurationElementsFor(SSEUIPlugin.ID, EXTENSION_POINT)));
	
		//for each extension
		for (Iterator iter= extensionElements.iterator(); iter.hasNext();) {
			IConfigurationElement element = (IConfigurationElement) iter.next();
			try {
				CommentingStrategy newCommentingStrategy = null;
				Map commentingStrategyRegistry = null;
				//either a block or line commenting strategy
				if(element.getName().equals(ELEM_PROPOSAL_BLOCK_COMMENTING_STRATEGY)) {
					String prefix = element.getAttribute(ATTR_PREFIX);
					checkExtensionAttributeNotNull(prefix, ATTR_PREFIX, element);
					
					String suffix = element.getAttribute(ATTR_SUFFIX);
					checkExtensionAttributeNotNull(suffix, ATTR_SUFFIX, element);
					
					if(prefix != null && suffix != null) {
						newCommentingStrategy = new BlockCommentingStrategy(prefix, suffix);
						commentingStrategyRegistry = this.fBlockCommentTypes;
					}
				} else if(element.getName().equals(ELEM_PROPOSAL_LINE_COMMENTING_STRATEGY)) {
					String prefix = element.getAttribute(ATTR_PREFIX);
					checkExtensionAttributeNotNull(prefix, ATTR_PREFIX, element);
					
					if(prefix != null) {
						newCommentingStrategy = new LineCommentingStrategy(prefix);
						commentingStrategyRegistry = this.fLineCommentTypes;
					}
				}
				
				//add the new strategy to the registry
				if(commentingStrategyRegistry != null && newCommentingStrategy != null) {
					addCommentingStrategyToRegistry(element, commentingStrategyRegistry, newCommentingStrategy);
				} else {
					Logger.log(Logger.WARNING, "Invalid CommentingStrategy extension: " + element); //$NON-NLS-1$
				}
			} catch (CoreException e) {
				Logger.logException(e);
			} catch (InvalidRegistryObjectException x) {
				/* Element is not valid any longer as the contributing plug-in was unloaded or for
				 * some other reason. Do not include the extension in the list and log it
				 */
				String message = "The extension ''" + element.toString() + "'' is invalid."; //$NON-NLS-1$ //$NON-NLS-2$
				IStatus status= new Status(IStatus.WARNING, SSEUIPlugin.ID, IStatus.WARNING, message, x);
				Logger.log(status);
			}
		}
	}
	
	/**
	 * <p>Checks that the given attribute value is not <code>null</code>.</p>
	 *
	 * @param value the object to check if not null
	 * @param attribute the attribute
	 * 
	 * @throws InvalidRegistryObjectException if the registry element is no longer valid
	 * @throws CoreException if <code>value</code> is <code>null</code>
	 */
	private static void checkExtensionAttributeNotNull(Object value, String attribute,
			IConfigurationElement element) throws InvalidRegistryObjectException, CoreException {
		
		if (value == null) {
			String message = "The extension \"" + element.getDeclaringExtension().getUniqueIdentifier() + //$NON-NLS-1$
				"\" from plug-in \"" + element.getContributor().getName() + //$NON-NLS-1$
				"\" did not specify a value for the required \"" + attribute + //$NON-NLS-1$
				"\" attribute for the element \"" + element.getName() + "\". Disabling the extension."; //$NON-NLS-1$ //$NON-NLS-2$
			IStatus status= new Status(IStatus.WARNING, SSEUIPlugin.ID, IStatus.OK, message, null);
			throw new CoreException(status);
		}
	}
	
	/**
	 * <p>Using the content type element children of the given element add a copy of the given
	 * base commenting strategy to the given registry</p>
	 * 
	 * @param element a {@link IConfigurationElement} with contentType element children
	 * @param commentingStrategyRegistry {@link Map} of content type ids to {@link CommentingStrategy}s to register
	 * the given {@link CommentingStrategy} with based on the <code>element</code>
	 * @param baseCommentingStrategy {@link CommentingStrategy} that will be cloned and configured for each
	 * content type in the given <code>element</code>
	 */
	private static void addCommentingStrategyToRegistry(IConfigurationElement element,
			Map commentingStrategyRegistry, CommentingStrategy baseCommentingStrategy) {
		
		//get all the content type elements
		IConfigurationElement[] contentTypeElements = element.getChildren(ELEM_CONTENT_TYPE);
		if(contentTypeElements.length > 0) {
			for(int contentTypeIndex = 0; contentTypeIndex < contentTypeElements.length; ++contentTypeIndex) {
				try {
					String contentTypeID = contentTypeElements[contentTypeIndex].getAttribute(ATTR_ID);
					checkExtensionAttributeNotNull(contentTypeID, ATTR_ID, contentTypeElements[contentTypeIndex]);
					
					List commentTypes = (List)commentingStrategyRegistry.get(contentTypeID);
					if(commentTypes == null) {
						commentTypes = new ArrayList();
						commentingStrategyRegistry.put(contentTypeID, commentTypes);
					}
					
					//this element is required
					List allowablePartitionTypeIDs = new ArrayList();
					IConfigurationElement[] allowablePartitionTypes =
						contentTypeElements[contentTypeIndex].getChildren(ELEM_ALLOWABLE_PARTITION_TYPES);
					boolean anyPartitionType = false;
					//determine anyPartitionType attribute value
					String anyPartitionTypeValue = allowablePartitionTypes[0].getAttribute(ATTR_ANY_PARTITION_TYPE);
					if(anyPartitionTypeValue != null) {
						anyPartitionType = Boolean.valueOf(anyPartitionTypeValue).booleanValue();
					}
					
					//get the optional partition types
					allowablePartitionTypes = allowablePartitionTypes[0].getChildren(ELEM_PARTITION_TYPE);
					if(allowablePartitionTypes.length > 0) {
						for (int partitionTypeIndex = 0; partitionTypeIndex < allowablePartitionTypes.length; ++partitionTypeIndex) {
							String partitionTypeID = allowablePartitionTypes[partitionTypeIndex].getAttribute(ATTR_ID);
							checkExtensionAttributeNotNull(partitionTypeID, ATTR_ID, allowablePartitionTypes[partitionTypeIndex]);
							
							allowablePartitionTypeIDs.add(partitionTypeID);
						}
					}
					
					//this element is optional
					List requiredPartitionTypeIDs = new ArrayList();
					IConfigurationElement[] requiredPartitionTypes =
						contentTypeElements[contentTypeIndex].getChildren(ELEM_REQUIRED_PARTITION_TYPES);
					boolean requireAll = false;
					if(requiredPartitionTypes.length > 0) {
						//determine requireAll attribute value
						String requireAllValue = requiredPartitionTypes[0].getAttribute(ATTR_REQUIRE_ALL);
						if(requireAllValue != null) {
							requireAll = Boolean.valueOf(requireAllValue).booleanValue();
						}
						
						//get the required partition types
						requiredPartitionTypes = requiredPartitionTypes[0].getChildren(ELEM_PARTITION_TYPE);
						if(requiredPartitionTypes.length > 0) {
							for (int partitionTypeIndex = 0; partitionTypeIndex < requiredPartitionTypes.length; ++partitionTypeIndex) {
								String partitionTypeID = requiredPartitionTypes[partitionTypeIndex].getAttribute(ATTR_ID);
								checkExtensionAttributeNotNull(partitionTypeID, ATTR_ID, requiredPartitionTypes[partitionTypeIndex]);
								
								requiredPartitionTypeIDs.add(partitionTypeID);
							}
						}
					}
					
					//get the optional associated comment partition type ID
					String associatedCommentPartitionTypeID =
						contentTypeElements[contentTypeIndex].getAttribute(ATTR_ASSOCIATED_COMMENT_PARTITION_TPYPE_ID);
					
					//register the strategy
					CommentingStrategy newCommentingStrategy = (CommentingStrategy)baseCommentingStrategy.clone();
					newCommentingStrategy.setPartitionInformation(allowablePartitionTypeIDs, anyPartitionType,
							requiredPartitionTypeIDs, requireAll, associatedCommentPartitionTypeID);
					commentTypes.add(newCommentingStrategy);
				} catch(CoreException e) {
					Logger.logException(e);
				}
			}
		} else {
			Logger.log(Logger.WARNING, "The commmentying strategy element: " + element +//$NON-NLS-1$
					" does not contain any requried " + ELEM_CONTENT_TYPE + "s"); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2010 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
 *******************************************************************************/
package org.eclipse.wst.sse.ui.internal.comment;

import java.util.List;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
import org.eclipse.wst.sse.ui.internal.Logger;

/**
 * <p>Represents a Block Comment commenting strategy</p>
 */
public class BlockCommentingStrategy extends CommentingStrategy {
	/** the prefix of the block comment associated with this strategy */
	private String fPrefix;
	
	/** the suffix of the block comment associated with this strategy */
	private String fSuffix;
	
	/**
	 * @param prefix the prefix of the block comment associated with this strategy
	 * @param suffix the suffix of the block comment associated with this strategy
	 */
	public BlockCommentingStrategy(String prefix, String suffix) {
		super();
		this.fPrefix = prefix;
		this.fSuffix = suffix;
	}

	/**
	 * <p>When applying a block comment it also removes any block comments associated
	 * with this strategy that would now be enclosed by the new block comment</p>
	 * 
	 * @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#apply(
	 * 	org.eclipse.wst.sse.core.internal.provisional.IStructuredModel, int, int)
	 */
	public void apply(IStructuredDocument document, int offset, int length) throws BadLocationException {
		int commentPrefixOffset = offset;
		int commentSuffixOffset = commentPrefixOffset + length;
		
		try {
			document.replace(commentSuffixOffset, 0, " " + this.fSuffix); //$NON-NLS-1$
			this.remove(document, commentPrefixOffset + this.fPrefix.length(), length, false);
			document.replace(commentPrefixOffset, 0, this.fPrefix + " "); //$NON-NLS-1$
		}
		catch (BadLocationException e) {
			Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
		}
	}

	/**
	 * @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#remove(
	 * 	org.eclipse.jface.text.IDocument, int, int)
	 */
	public void remove(IStructuredDocument document, int offset, int length, boolean removeEnclosing) throws BadLocationException {
		IRegion region = new Region(offset, length);
		ITypedRegion[] typedRegions = document.computePartitioning(region.getOffset(), region.getLength());
		List commentRegions = this.getAssociatedCommentedRegions(typedRegions);
		
		//remove in reverse order as to not effect offset of other regions
		for(int i = commentRegions.size()-1; i >= 0; --i) {
			try {
				//get the comment region
				ITypedRegion typedRegion = (ITypedRegion)commentRegions.get(i);
				IRegion commentRegion = new Region(typedRegion.getOffset(), typedRegion.getLength());

				/* because of the nature of structured regions the comment region could actually be a
				 * sub region that needs to be drilled down too
				 */
				if(!this.alreadyCommenting(document, commentRegion)) {
					IStructuredDocumentRegion structuredRegion =
						document.getRegionAtCharacterOffset(commentRegion.getOffset());
					
					commentRegion = new Region(structuredRegion.getStartOffset(), structuredRegion.getLength());
					
					if(!this.alreadyCommenting(document, commentRegion)) {
						ITextRegion enclosedRegion = structuredRegion.getRegionAtCharacterOffset(typedRegion.getOffset());
						int enclosedOffset = structuredRegion.getStartOffset(enclosedRegion);
						commentRegion = new Region(enclosedOffset, structuredRegion.getTextEndOffset(enclosedRegion)-enclosedOffset);
					}
				}
				
				//at this point should have found the comment region, if not there is an issue
				if(this.alreadyCommenting(document, commentRegion)) {
					String regionContent = document.get(commentRegion.getOffset(), commentRegion.getLength());
					
					//if found the comment prefix and suffix then uncomment, otherwise log error
					int commentPrefixOffset = commentRegion.getOffset() + regionContent.indexOf(this.fPrefix);
					int commentSuffixOffset = commentRegion.getOffset();
					commentSuffixOffset += regionContent.lastIndexOf(this.fSuffix);
					
					//remove comment block depending on if its an enclosing comment block and weather that is allowed
					if(removeEnclosing || (commentPrefixOffset >= offset && commentSuffixOffset <= offset+length)) {
						uncomment(document, commentPrefixOffset, this.fPrefix, commentSuffixOffset, this.fSuffix);
					}
				} else {
					Logger.log(Logger.ERROR,
							"BlockCommentingStrategy#remove could not find the commenting region to remove"); //$NON-NLS-1$
				}
			} catch(BadLocationException e) {
				Logger.logException("This shoudl only ever happen if somethign has gone wrong with the partitioning", e); //$NON-NLS-1$
			}
		}
	}
	
	/**
	 * <p>A region is already commented by this strategy if it starts with the strategy's associated
	 * prefix and ends with its associated suffix, ignoring any trailing or leading whitespace</p>
	 * 
	 * @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#alreadyCommenting(
	 * 	org.eclipse.jface.text.IDocument, org.eclipse.jface.text.IRegion)
	 */
	public boolean alreadyCommenting(IStructuredDocument document, IRegion region) throws BadLocationException {
		String regionContent = document.get(region.getOffset(), region.getLength()).trim();
		return regionContent.startsWith(this.fPrefix) && regionContent.endsWith(this.fSuffix);
	}
	
	/**
	 * @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#clone()
	 */
	public Object clone() {
		return new BlockCommentingStrategy(this.fPrefix, this.fSuffix);
	}
}

Return to bug 86520

Lines 83-89 Link Here

(-)plugin.xml (-94 / +15 lines)
83	target="org.eclipse.core.runtime.xml, org.eclipse.wst.xml.core.xmlsource" />	83	target="org.eclipse.core.runtime.xml, org.eclipse.wst.xml.core.xmlsource" />
84	<provisionalDefinition	84	<provisionalDefinition
85	type="activecontexts"	85	type="activecontexts"
86	value="org.eclipse.core.runtime.xml, org.eclipse.wst.xml.navigation, org.eclipse.wst.xml.cleanup, org.eclipse.wst.xml.comments, org.eclipse.wst.xml.selection, org.eclipse.wst.xml.dependencies, org.eclipse.wst.xml.grammar, org.eclipse.wst.xml.expand, org.eclipse.wst.xml.occurrences"	86	value="org.eclipse.core.runtime.xml, org.eclipse.wst.xml.navigation, org.eclipse.wst.xml.cleanup, org.eclipse.wst.xml.selection, org.eclipse.wst.xml.dependencies, org.eclipse.wst.xml.grammar, org.eclipse.wst.xml.expand, org.eclipse.wst.xml.occurrences"
87	target="org.eclipse.core.runtime.xml" />	87	target="org.eclipse.core.runtime.xml" />
88	</extension>	88	</extension>
89		89
Lines 107-118 Link Here
107	id="org.eclipse.wst.xml.cleanup">	107	id="org.eclipse.wst.xml.cleanup">
108	</context>	108	</context>
109	<context	109	<context
110	name="%scope.structured.text.editor.xml.comments.name"
111	parentId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
112	description="%scope.structured.text.editor.xml.comments.description"
113	id="org.eclipse.wst.xml.comments">
114	</context>
115	<context
116	name="%scope.structured.text.editor.xml.selection.name"	110	name="%scope.structured.text.editor.xml.selection.name"
117	parentId="org.eclipse.wst.sse.ui.structuredTextEditorScope"	111	parentId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
118	description="%scope.structured.text.editor.xml.selection.description"	112	description="%scope.structured.text.editor.xml.selection.description"
Lines 1005-1057 Link Here
1005	</command>	999	</command>
1006	</toolbar>	1000	</toolbar>
1007	</menuContribution>	1001	</menuContribution>
1008
1009	<menuContribution locationURI="menu:sourceMenuId?after=sourceBegin">
1010	<command commandId="org.eclipse.wst.sse.ui.toggle.comment"
1011	id="ToggleComment"
1012	mnemonic="%command.toggle.comment.mnemonic"
1013	style="push">
1014	<visibleWhen checkEnabled="false">
1015	<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
1016	</visibleWhen>
1017	</command>
1018	<command commandId="org.eclipse.wst.sse.ui.add.block.comment"
1019	id="AddBlockComment"
1020	mnemonic="%command.add.block.comment.mnemonic"
1021	style="push">
1022	<visibleWhen checkEnabled="false">
1023	<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
1024	</visibleWhen>
1025	</command>
1026	<command commandId="org.eclipse.wst.sse.ui.remove.block.comment"
1027	id="RemoveBlockComment"
1028	mnemonic="%command.remove.block.comment.mnemonic"
1029	style="push">
1030	<visibleWhen checkEnabled="false">
1031	<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
1032	</visibleWhen>
1033	</command>
1034	</menuContribution>
1035
1036	<menuContribution
1037	locationURI="popup:sourcePopupMenuId?after=sourceBegin">
1038	<command commandId="org.eclipse.wst.sse.ui.toggle.comment" id="ToggleComment" style="push">
1039	<visibleWhen checkEnabled="false">
1040	<reference definitionId="org.eclipse.wst.xml.ui.comments"></reference>
1041	</visibleWhen>
1042	</command>
1043	<command commandId="org.eclipse.wst.sse.ui.add.block.comment" id="AddBlockComment" style="push">
1044	<visibleWhen checkEnabled="false">
1045	<reference definitionId="org.eclipse.wst.xml.ui.comments"></reference>
1046	</visibleWhen>
1047	</command>
1048	<command commandId="org.eclipse.wst.sse.ui.remove.block.comment" id="RemoveBlockComment" style="push">
1049	<visibleWhen checkEnabled="false">
1050	<reference definitionId="org.eclipse.wst.xml.ui.comments"></reference>
1051	</visibleWhen>
1052	</command>
1053	<separator name="format" visible="true"></separator>
1054	</menuContribution>
1055	</extension>	1002	</extension>
1056		1003
1057	<extension point="org.eclipse.core.expressions.definitions">	1004	<extension point="org.eclipse.core.expressions.definitions">
Lines 1085-1100 Link Here
1085	</extension>	1032	</extension>
1086		1033
1087	<extension point="org.eclipse.core.expressions.definitions">	1034	<extension point="org.eclipse.core.expressions.definitions">
1088	<definition id="org.eclipse.wst.xml.ui.comments">
1089	<with variable="activeContexts">
1090	<iterate operator="or">
1091	<equals value="org.eclipse.wst.xml.comments"/>
1092	</iterate>
1093	</with>
1094	</definition>
1095	</extension>
1096
1097	<extension point="org.eclipse.core.expressions.definitions">
1098	<definition id="org.eclipse.wst.xml.ui.cleanup">	1035	<definition id="org.eclipse.wst.xml.ui.cleanup">
1099	<with variable="activeContexts">	1036	<with variable="activeContexts">
1100	<iterate operator="or">	1037	<iterate operator="or">
Lines 1182-1217 Link Here
1182	</enabledWhen>	1119	</enabledWhen>
1183	</handler>	1120	</handler>
1184	<handler	1121	<handler
1185	class="org.eclipse.wst.xml.ui.internal.handlers.ToggleCommentHandler"
1186	commandId="org.eclipse.wst.sse.ui.toggle.comment">
1187	<activeWhen>
1188	<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
1189	</activeWhen>
1190	<enabledWhen>
1191	<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
1192	</enabledWhen>
1193	</handler>
1194	<handler
1195	class="org.eclipse.wst.xml.ui.internal.handlers.AddBlockCommentHandler"
1196	commandId="org.eclipse.wst.sse.ui.add.block.comment">
1197	<activeWhen>
1198	<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
1199	</activeWhen>
1200	<enabledWhen>
1201	<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
1202	</enabledWhen>
1203	</handler>
1204	<handler
1205	class="org.eclipse.wst.xml.ui.internal.handlers.RemoveBlockCommentHandler"
1206	commandId="org.eclipse.wst.sse.ui.remove.block.comment">
1207	<activeWhen>
1208	<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
1209	</activeWhen>
1210	<enabledWhen>
1211	<reference definitionId="org.eclipse.wst.xml.ui.comments"/>
1212	</enabledWhen>
1213	</handler>
1214	<handler
1215	class="org.eclipse.wst.xml.ui.internal.handlers.StructuredSelectEnclosingXMLHandler"	1122	class="org.eclipse.wst.xml.ui.internal.handlers.StructuredSelectEnclosingXMLHandler"
1216	commandId="org.eclipse.wst.sse.ui.structure.select.enclosing">	1123	commandId="org.eclipse.wst.sse.ui.structure.select.enclosing">
1217	<activeWhen>	1124	<activeWhen>
Lines 1670-1675 Link Here
1670	</inserter>	1577	</inserter>
1671	</extension>	1578	</extension>
1672	<extension	1579	<extension
		1580	point="org.eclipse.wst.sse.ui.commentingStrategy">
		1581	<blockCommentingStrategy
		1582	prefix="<!--"
		1583	suffix="-->">
		1584	<contentType
		1585	id="org.eclipse.core.runtime.xml"
		1586	associatedCommentPartitionTypeID="org.eclipse.wst.xml.XML_COMMENT">
		1587	<allowablePartitionTypes
		1588	anyPartitionType="true">
		1589	</allowablePartitionTypes>
		1590	</contentType>
		1591	</blockCommentingStrategy>
		1592	</extension>
		1593	<extension
1673	point="org.eclipse.wst.sse.ui.completionProposal">	1594	point="org.eclipse.wst.sse.ui.completionProposal">
1674	<proposalCategory	1595	<proposalCategory
1675	icon="icons/full/obj16/tag-generic.gif"	1596	icon="icons/full/obj16/tag-generic.gif"

Lines 136-147 Link Here

(-)plugin.properties (-6 lines)
136	Colors.cdataBorder=CDATA Border	136	Colors.cdataBorder=CDATA Border
137	Colors.cdataText=CDATA Text	137	Colors.cdataText=CDATA Text
138	Colors.entityReference=Entity Reference	138	Colors.entityReference=Entity Reference
139
140	# Menu contributions
141	command.toggle.comment.mnemonic=T
142	command.add.block.comment.mnemonic=A
143	command.remove.block.comment.mnemonic=R
144
145	# content assist	139	# content assist
146	proposalCategory.xmlTags=XML Tag Proposals	140	proposalCategory.xmlTags=XML Tag Proposals
147	proposalCategory.xmlTemplates=XML Template Proposals	141	proposalCategory.xmlTemplates=XML Template Proposals

Removed Link Here

(-)src/org/eclipse/wst/xml/ui/internal/handlers/CommentHandler.java (-103 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Standards for Technology in Automotive Retail and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* David Carver - initial API and implementation, bug 212330
10	*
11	*******************************************************************************/
12	package org.eclipse.wst.xml.ui.internal.handlers;
13
14	import org.eclipse.core.commands.AbstractHandler;
15	import org.eclipse.core.commands.ExecutionEvent;
16	import org.eclipse.core.commands.ExecutionException;
17	import org.eclipse.core.commands.IHandler;
18	import org.eclipse.jface.text.BadLocationException;
19	import org.eclipse.jface.text.IDocument;
20	import org.eclipse.jface.text.ITextSelection;
21	import org.eclipse.jface.text.TextSelection;
22	import org.eclipse.jface.viewers.ISelection;
23	import org.eclipse.jface.viewers.ISelectionProvider;
24	import org.eclipse.ui.IEditorPart;
25	import org.eclipse.ui.handlers.HandlerUtil;
26	import org.eclipse.ui.texteditor.ITextEditor;
27	import org.eclipse.wst.xml.ui.internal.Logger;
28
29	public class CommentHandler extends AbstractHandler implements IHandler {
30	static final String CLOSE_COMMENT = "-->"; //$NON-NLS-1$
31	static final String OPEN_COMMENT = "<!--"; //$NON-NLS-1$
32
33	public CommentHandler() {
34	super();
35	}
36
37	public Object execute(ExecutionEvent event) throws ExecutionException {
38	IEditorPart editor = HandlerUtil.getActiveEditor(event);
39	ITextEditor textEditor = null;
40	if (editor instanceof ITextEditor)
41	textEditor = (ITextEditor) editor;
42	else {
43	Object o = editor.getAdapter(ITextEditor.class);
44	if (o != null)
45	textEditor = (ITextEditor) o;
46	}
47	if (textEditor != null) {
48	IDocument document = textEditor.getDocumentProvider().getDocument(textEditor.getEditorInput());
49	if (document != null) {
50	// get current text selection
51	ITextSelection textSelection = getCurrentSelection(textEditor);
52	if (textSelection.isEmpty()) {
53	return null;
54	}
55
56	processAction(textEditor, document, textSelection);
57	}
58	}
59
60	return null;
61	}
62
63	protected ITextSelection getCurrentSelection(ITextEditor textEditor) {
64	ISelectionProvider provider = textEditor.getSelectionProvider();
65	if (provider != null) {
66	ISelection selection = provider.getSelection();
67	if (selection instanceof ITextSelection) {
68	return (ITextSelection) selection;
69	}
70	}
71	return TextSelection.emptySelection();
72	}
73
74	void processAction(ITextEditor textEditor, IDocument document, ITextSelection textSelection) {
75	// Implementations to over ride.
76	}
77
78	protected void removeOpenCloseComments(IDocument document, int offset, int length) {
79	try {
80	int adjusted_length = length;
81
82	// remove open comments
83	String string = document.get(offset, length);
84	int index = string.lastIndexOf(OPEN_COMMENT);
85	while (index != -1) {
86	document.replace(offset + index, OPEN_COMMENT.length(), ""); //$NON-NLS-1$
87	index = string.lastIndexOf(OPEN_COMMENT, index - 1);
88	adjusted_length -= OPEN_COMMENT.length();
89	}
90
91	// remove close comments
92	string = document.get(offset, adjusted_length);
93	index = string.lastIndexOf(CLOSE_COMMENT);
94	while (index != -1) {
95	document.replace(offset + index, CLOSE_COMMENT.length(), ""); //$NON-NLS-1$
96	index = string.lastIndexOf(CLOSE_COMMENT, index - 1);
97	}
98	}
99	catch (BadLocationException e) {
100	Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
101	}
102	}
103	}

Lines 63-69 Link Here

(-)plugin.xml (-2 / +37 lines)
63	target="org.eclipse.wst.html.core.htmlsource" />	63	target="org.eclipse.wst.html.core.htmlsource" />
64	<provisionalDefinition	64	<provisionalDefinition
65	type="activecontexts"	65	type="activecontexts"
66	value="org.eclipse.wst.html.core.htmlsource, org.eclipse.wst.html.occurrences, org.eclipse.core.runtime.xml, org.eclipse.wst.xml.navigation, org.eclipse.wst.xml.comments, org.eclipse.wst.xml.selection"	66	value="org.eclipse.wst.html.core.htmlsource, org.eclipse.wst.html.occurrences, org.eclipse.core.runtime.xml, org.eclipse.wst.xml.navigation, org.eclipse.wst.xml.selection, org.eclipse.wst.sse.comments"
67	target="org.eclipse.wst.html.core.htmlsource" />	67	target="org.eclipse.wst.html.core.htmlsource" />
68	</extension>	68	</extension>
69	<extension	69	<extension
Lines 617-623 Link Here
617	</enabledWhen>	617	</enabledWhen>
618	</handler>	618	</handler>
619	</extension>	619	</extension>
620		620
		621	<extension
		622	point="org.eclipse.wst.sse.ui.commentingStrategy">
		623	<blockCommentingStrategy
		624	prefix="<!--"
		625	suffix="-->">
		626	<contentType
		627	id="org.eclipse.wst.html.core.htmlsource"
		628	associatedCommentPartitionTypeID="org.eclipse.wst.html.HTML_COMMENT">
		629	<requiredPartitionTypes
		630	requireAll="false">
		631	<partitionType
		632	id="org.eclipse.wst.html.HTML_DEFAULT">
		633	</partitionType>
		634	<partitionType
		635	id="org.eclipse.wst.html.HTML_DECLARATION">
		636	</partitionType>
		637	<partitionType
		638	id="org.eclipse.wst.html.SCRIPT.EVENTHANDLER">
		639	</partitionType>
		640	<partitionType
		641	id="org.eclipse.wst.xml.XML_PI">
		642	</partitionType>
		643	</requiredPartitionTypes>
		644	<allowablePartitionTypes
		645	anyPartitionType="false">
		646	<partitionType
		647	id="org.eclipse.wst.css.STYLE">
		648	</partitionType>
		649	<partitionType
		650	id="org.eclipse.wst.html.SCRIPT">
		651	</partitionType>
		652	</allowablePartitionTypes>
		653	</contentType>
		654	</blockCommentingStrategy>
		655	</extension>
621	<!-- Set up a definition for HTML Content Types -->	656	<!-- Set up a definition for HTML Content Types -->
622	<extension point="org.eclipse.core.expressions.definitions">	657	<extension point="org.eclipse.core.expressions.definitions">
623	<definition id="org.eclipse.wst.html.ui.htmlContentType.definition">	658	<definition id="org.eclipse.wst.html.ui.htmlContentType.definition">

Lines 50-56 Link Here

(-)plugin.xml (-90 / +39 lines)
50	target="org.eclipse.wst.css.core.csssource" />	50	target="org.eclipse.wst.css.core.csssource" />
51	<provisionalDefinition	51	<provisionalDefinition
52	type="activecontexts"	52	type="activecontexts"
53	value="org.eclipse.wst.css.core.csssource"	53	value="org.eclipse.wst.css.core.csssource, org.eclipse.wst.sse.comments"
54	target="org.eclipse.wst.css.core.csssource" />	54	target="org.eclipse.wst.css.core.csssource" />
55	</extension>	55	</extension>
56		56
Lines 267-314 Link Here
267	</enabledWhen>	267	</enabledWhen>
268	</handler>	268	</handler>
269	<handler	269	<handler
270	class="org.eclipse.wst.css.ui.internal.handlers.ToggleCommentHandler"
271	commandId="org.eclipse.wst.sse.ui.toggle.comment">
272	<activeWhen>
273	<reference
274	definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
275	</reference>
276	</activeWhen>
277	<enabledWhen>
278	<reference
279	definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
280	</reference>
281	</enabledWhen>
282	</handler>
283	<handler
284	class="org.eclipse.wst.css.ui.internal.handlers.AddBlockCommentHandler"
285	commandId="org.eclipse.wst.sse.ui.add.block.comment">
286	<activeWhen>
287	<reference
288	definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
289	</reference>
290	</activeWhen>
291	<enabledWhen>
292	<reference
293	definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
294	</reference>
295	</enabledWhen>
296	</handler>
297	<handler
298	class="org.eclipse.wst.css.ui.internal.handlers.RemoveBlockCommentHandler"
299	commandId="org.eclipse.wst.sse.ui.remove.block.comment">
300	<activeWhen>
301	<reference
302	definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
303	</reference>
304	</activeWhen>
305	<enabledWhen>
306	<reference
307	definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition">
308	</reference>
309	</enabledWhen>
310	</handler>
311	<handler
312	class="org.eclipse.wst.css.ui.internal.handlers.StructuredSelectEnclosingHandler"	270	class="org.eclipse.wst.css.ui.internal.handlers.StructuredSelectEnclosingHandler"
313	commandId="org.eclipse.wst.sse.ui.structure.select.enclosing">	271	commandId="org.eclipse.wst.sse.ui.structure.select.enclosing">
314	<activeWhen>	272	<activeWhen>
Lines 351-403 Link Here
351	</handler>	309	</handler>
352	</extension>	310	</extension>
353		311
354	<extension point="org.eclipse.ui.menus">
355	<menuContribution
356	locationURI="popup:sourcePopupMenuId?before=sourceBegin">
357	<command commandId="org.eclipse.wst.sse.ui.toggle.comment" id="ToggleComment" style="push">
358	<visibleWhen checkEnabled="false">
359	<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition"/>
360	</visibleWhen>
361	</command>
362	<command commandId="org.eclipse.wst.sse.ui.add.block.comment" id="AddBlockComment" style="push">
363	<visibleWhen checkEnabled="false">
364	<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition" />
365	</visibleWhen>
366	</command>
367	<command commandId="org.eclipse.wst.sse.ui.remove.block.comment" id="RemoveBlockComment" style="push">
368	<visibleWhen checkEnabled="false">
369	<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition" />
370	</visibleWhen>
371	</command>
372	</menuContribution>
373
374	<menuContribution locationURI="menu:sourceMenuId?before=sourceBegin">
375	<command commandId="org.eclipse.wst.sse.ui.toggle.comment"
376	id="ToggleComment"
377	mnemonic="%command.toggle.comment.mnemonic"
378	style="push">
379	<visibleWhen checkEnabled="false">
380	<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition"/>
381	</visibleWhen>
382	</command>
383	<command commandId="org.eclipse.wst.sse.ui.add.block.comment"
384	id="AddBlockComment"
385	mnemonic="%command.add.block.comment.mnemonic"
386	style="push">
387	<visibleWhen checkEnabled="false">
388	<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition"/>
389	</visibleWhen>
390	</command>
391	<command commandId="org.eclipse.wst.sse.ui.remove.block.comment"
392	id="RemoveBlockComment"
393	mnemonic="%command.remove.block.comment.mnemonic"
394	style="push">
395	<visibleWhen checkEnabled="false">
396	<reference definitionId="org.eclipse.wst.css.ui.cssSourceContributions.definition"/>
397	</visibleWhen>
398	</command>
399	</menuContribution>
400	</extension>
401	<!-- CSS editor actions -->	312	<!-- CSS editor actions -->
402	<extension point="org.eclipse.ui.editorActions">	313	<extension point="org.eclipse.ui.editorActions">
403	<!--<editorContribution	314	<!--<editorContribution
Lines 701-706 Link Here
701	</inserter>	612	</inserter>
702	</extension>	613	</extension>
703	<extension	614	<extension
		615	point="org.eclipse.wst.sse.ui.commentingStrategy">
		616	<blockCommentingStrategy
		617	prefix="/*"
		618	suffix="*/">
		619	<contentType
		620	id="org.eclipse.wst.html.core.htmlsource">
		621	<allowablePartitionTypes
		622	anyPartitionType="false">
		623	</allowablePartitionTypes>
		624	<requiredPartitionTypes
		625	requireAll="true">
		626	<partitionType
		627	id="org.eclipse.wst.css.STYLE">
		628	</partitionType>
		629	</requiredPartitionTypes>
		630	</contentType>
		631	<contentType
		632	associatedCommentPartitionTypeID="org.eclipse.wst.css.COMMENT"
		633	id="org.eclipse.wst.css.core.csssource">
		634	<allowablePartitionTypes
		635	anyPartitionType="true">
		636	</allowablePartitionTypes>
		637	</contentType>
		638	<contentType
		639	id="org.eclipse.jst.jsp.core.jspsource">
		640	<allowablePartitionTypes
		641	anyPartitionType="false">
		642	</allowablePartitionTypes>
		643	<requiredPartitionTypes
		644	requireAll="true">
		645	<partitionType
		646	id="org.eclipse.wst.css.STYLE">
		647	</partitionType>
		648	</requiredPartitionTypes>
		649	</contentType>
		650	</blockCommentingStrategy>
		651	</extension>
		652	<extension
704	point="org.eclipse.wst.sse.ui.completionProposal">	653	point="org.eclipse.wst.sse.ui.completionProposal">
705	<proposalCategory	654	<proposalCategory
706	icon="icons/full/obj16/tag_selector.gif"	655	icon="icons/full/obj16/tag_selector.gif"

Removed Link Here

(-)src/org/eclipse/wst/css/ui/internal/handlers/ToggleCommentHandler.java (-159 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.wst.css.ui.internal.handlers;
12
13	import org.eclipse.jface.text.BadLocationException;
14	import org.eclipse.jface.text.IDocument;
15	import org.eclipse.jface.text.IRegion;
16	import org.eclipse.jface.text.ITextSelection;
17	import org.eclipse.jface.text.Position;
18	import org.eclipse.jface.text.TextSelection;
19	import org.eclipse.jface.viewers.ISelectionProvider;
20	import org.eclipse.ui.texteditor.ITextEditor;
21	import org.eclipse.wst.css.ui.internal.Logger;
22	import org.eclipse.wst.sse.core.StructuredModelManager;
23	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
24	import org.eclipse.wst.css.ui.internal.CSSUIMessages;
25
26	public class ToggleCommentHandler extends AbstractCommentHandler {
27
28	protected void processAction(ITextEditor textEditor, IDocument document, ITextSelection textSelection) {
29	// get text selection lines info
30	int selectionStartLine = textSelection.getStartLine();
31	int selectionEndLine = textSelection.getEndLine();
32	try {
33	int selectionEndLineOffset = document.getLineOffset(selectionEndLine);
34	int selectionEndOffset = textSelection.getOffset() + textSelection.getLength();
35
36	// adjust selection end line
37	if ((selectionEndLine > selectionStartLine) && (selectionEndLineOffset == selectionEndOffset)) {
38	selectionEndLine--;
39	}
40
41	}
42	catch (BadLocationException e) {
43	Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
44	}
45
46	// save the selection position since it will be changing
47	Position selectionPosition = null;
48	boolean updateStartOffset = false;
49	try {
50	selectionPosition = new Position(textSelection.getOffset(), textSelection.getLength());
51	document.addPosition(selectionPosition);
52
53	// extra check if commenting from beginning of line
54	int selectionStartLineOffset = document.getLineOffset(selectionStartLine);
55	if ((textSelection.getLength() > 0) && (selectionStartLineOffset == textSelection.getOffset()) && !isCommentLine(document, selectionStartLine)) {
56	updateStartOffset = true;
57	}
58	}
59	catch (BadLocationException e) {
60	Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
61	}
62
63	processAction(document, selectionStartLine, selectionEndLine);
64
65	updateCurrentSelection(textEditor, selectionPosition, document, updateStartOffset);
66	}
67
68	private void processAction(IDocument document, int selectionStartLine, int selectionEndLine) {
69	IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForEdit(document);
70	if (model != null) {
71	try {
72	model.beginRecording(this, CSSUIMessages.ToggleComment_tooltip);
73	model.aboutToChangeModel();
74
75	for (int i = selectionStartLine; i <= selectionEndLine; i++) {
76	try {
77	if (document.getLineLength(i) > 0) {
78	if (isCommentLine(document, i)) {
79	int lineOffset = document.getLineOffset(i);
80	IRegion region = document.getLineInformation(i);
81	String string = document.get(region.getOffset(), region.getLength());
82	int openCommentOffset = lineOffset + string.indexOf(OPEN_COMMENT);
83	int closeCommentOffset = lineOffset + string.indexOf(CLOSE_COMMENT) - OPEN_COMMENT.length();
84	uncomment(document, openCommentOffset, closeCommentOffset);
85	}
86	else {
87	int openCommentOffset = document.getLineOffset(i);
88	int lineDelimiterLength = document.getLineDelimiter(i) == null ? 0 : document.getLineDelimiter(i).length();
89	int closeCommentOffset = openCommentOffset + document.getLineLength(i) - lineDelimiterLength + OPEN_COMMENT.length();
90	comment(document, openCommentOffset, closeCommentOffset);
91	}
92	}
93	}
94	catch (BadLocationException e) {
95	Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
96	}
97	}
98	}
99	finally {
100	model.changedModel();
101	model.endRecording(this);
102	model.releaseFromEdit();
103	}
104	}
105	}
106
107	private void updateCurrentSelection(ITextEditor textEditor, Position selectionPosition, IDocument document, boolean updateStartOffset) {
108	// update the selection if text selection changed
109	if (selectionPosition != null) {
110	ITextSelection selection = null;
111	if (updateStartOffset) {
112	selection = new TextSelection(document, selectionPosition.getOffset() - OPEN_COMMENT.length(), selectionPosition.getLength() + OPEN_COMMENT.length());
113	}
114	else {
115	selection = new TextSelection(document, selectionPosition.getOffset(), selectionPosition.getLength());
116	}
117	ISelectionProvider provider = textEditor.getSelectionProvider();
118	if (provider != null) {
119	provider.setSelection(selection);
120	}
121	document.removePosition(selectionPosition);
122	}
123	}
124
125	private boolean isCommentLine(IDocument document, int line) {
126	boolean isComment = false;
127
128	try {
129	IRegion region = document.getLineInformation(line);
130	String string = document.get(region.getOffset(), region.getLength()).trim();
131	isComment = (string.length() >= OPEN_COMMENT.length() + CLOSE_COMMENT.length()) && string.startsWith(OPEN_COMMENT) && string.endsWith(CLOSE_COMMENT);
132	}
133	catch (BadLocationException e) {
134	Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
135	}
136	return isComment;
137	}
138
139	private void comment(IDocument document, int openCommentOffset, int closeCommentOffset) {
140	try {
141	document.replace(openCommentOffset, 0, OPEN_COMMENT);
142	document.replace(closeCommentOffset, 0, CLOSE_COMMENT);
143	removeOpenCloseComments(document, openCommentOffset + OPEN_COMMENT.length(), closeCommentOffset - openCommentOffset - CLOSE_COMMENT.length());
144	}
145	catch (BadLocationException e) {
146	Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
147	}
148	}
149
150	private void uncomment(IDocument document, int openCommentOffset, int closeCommentOffset) {
151	try {
152	document.replace(openCommentOffset, OPEN_COMMENT.length(), ""); //$NON-NLS-1$
153	document.replace(closeCommentOffset, CLOSE_COMMENT.length(), ""); //$NON-NLS-1$
154	}
155	catch (BadLocationException e) {
156	Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
157	}
158	}
159	}

Lines 75-81 Link Here

(-)plugin.xml (-1 / +96 lines)
75	target="org.eclipse.jst.jsp.core.jspsource" />	75	target="org.eclipse.jst.jsp.core.jspsource" />
76	<provisionalDefinition	76	<provisionalDefinition
77	type="activecontexts"	77	type="activecontexts"
78	value="org.eclipse.jst.jsp.core.jspsource, org.eclipse.jst.jsp.ui.structured.text.editor.jsp.scope, org.eclipse.wst.html.core.htmlsource, org.eclipse.core.runtime.xml, org.eclipse.wst.xml.navigation, org.eclipse.wst.xml.comments, org.eclipse.wst.xml.selection"	78	value="org.eclipse.jst.jsp.core.jspsource, org.eclipse.jst.jsp.ui.structured.text.editor.jsp.scope, org.eclipse.wst.html.core.htmlsource, org.eclipse.core.runtime.xml, org.eclipse.wst.xml.navigation, org.eclipse.wst.xml.selection, , org.eclipse.wst.sse.comments"
79	target="org.eclipse.jst.jsp.core.jspsource" />	79	target="org.eclipse.jst.jsp.core.jspsource" />
80		80
81	<contentOutlineConfiguration	81	<contentOutlineConfiguration
Lines 1072-1077 Link Here
1072	</inserter>	1072	</inserter>
1073	</extension>	1073	</extension>
1074	<extension	1074	<extension
		1075	point="org.eclipse.wst.sse.ui.commentingStrategy">
		1076	<blockCommentingStrategy
		1077	prefix="<!--"
		1078	suffix="-->">
		1079	<contentType
		1080	associatedCommentPartitionTypeID="org.eclipse.wst.html.HTML_COMMENT"
		1081	id="org.eclipse.jst.jsp.core.jspsource">
		1082	<requiredPartitionTypes
		1083	requireAll="false">
		1084	<partitionType
		1085	id="org.eclipse.wst.html.HTML_DEFAULT">
		1086	</partitionType>
		1087	<partitionType
		1088	id="org.eclipse.wst.html.HTML_DECLARATION">
		1089	</partitionType>
		1090	<partitionType
		1091	id="org.eclipse.wst.html.SCRIPT.EVENTHANDLER">
		1092	</partitionType>
		1093	<partitionType
		1094	id="org.eclipse.wst.xml.XML_PI">
		1095	</partitionType>
		1096	</requiredPartitionTypes>
		1097	<allowablePartitionTypes
		1098	anyPartitionType="false">
		1099	<partitionType
		1100	id="org.eclipse.wst.css.STYLE">
		1101	</partitionType>
		1102	<partitionType
		1103	id="org.eclipse.wst.html.SCRIPT">
		1104	</partitionType>
		1105	</allowablePartitionTypes>
		1106	</contentType>
		1107	</blockCommentingStrategy>
		1108	<blockCommentingStrategy
		1109	prefix="<%--"
		1110	suffix="--%>">
		1111	<contentType
		1112	associatedCommentPartitionTypeID="org.eclipse.jst.jsp.JSP_COMMENT"
		1113	id="org.eclipse.jst.jsp.core.jspsource">
		1114	<requiredPartitionTypes
		1115	requireAll="false">
		1116	<partitionType
		1117	id="org.eclipse.jst.jsp.JSP_DIRECTIVE">
		1118	</partitionType>
		1119	<partitionType
		1120	id="org.eclipse.jst.jsp.DEFAULT_JSP">
		1121	</partitionType>
		1122	<partitionType
		1123	id="org.eclipse.jst.jsp.SCRIPT.DELIMITER">
		1124	</partitionType>
		1125	<partitionType
		1126	id="org.eclipse.jst.jsp.SCRIPT.JSP_EL">
		1127	</partitionType>
		1128	<partitionType
		1129	id="org.eclipse.jst.jsp.SCRIPT.JSP_EL2">
		1130	</partitionType>
		1131	</requiredPartitionTypes>
		1132	<allowablePartitionTypes
		1133	anyPartitionType="true">
		1134	</allowablePartitionTypes>
		1135	</contentType>
		1136	</blockCommentingStrategy>
		1137	<blockCommentingStrategy
		1138	prefix="/*"
1139	suffix="*/">
1140	<contentType
1141	id="org.eclipse.jst.jsp.core.jspsource">
1142	<requiredPartitionTypes
1143	requireAll="false">
1144	<partitionType
1145	id="org.eclipse.jst.jsp.SCRIPT.JAVA">
1146	</partitionType>
1147	</requiredPartitionTypes>
1148	<allowablePartitionTypes
1149	anyPartitionType="false">
1150	</allowablePartitionTypes>
1151	</contentType>
1152	</blockCommentingStrategy>
1153	<lineCommentingStrategy
1154	prefix="//">
1155	<contentType
1156	id="org.eclipse.jst.jsp.core.jspsource">
1157	<requiredPartitionTypes
1158	requireAll="false">
1159	<partitionType
1160	id="org.eclipse.jst.jsp.SCRIPT.JAVA">
1161	</partitionType>
1162	</requiredPartitionTypes>
1163	<allowablePartitionTypes
1164	anyPartitionType="false">
1165	</allowablePartitionTypes>
1166	</contentType>
1167	</lineCommentingStrategy>
1168	</extension>
1169	<extension
1075	point="org.eclipse.wst.sse.ui.completionProposal">	1170	point="org.eclipse.wst.sse.ui.completionProposal">
1076	<proposalCategory	1171	<proposalCategory
1077	icon="icons/full/obj16/tag-template.gif"	1172	icon="icons/full/obj16/tag-template.gif"

Lines 30-46 Link Here

(-)plugin.properties (+6 lines)
30	Character_Pairing.name=Character Pairing Extension	30	Character_Pairing.name=Character Pairing Extension
31	Completion_Proposal.name=Completion Proposal	31	Completion_Proposal.name=Completion Proposal
32	Completion_Proposal_Categories_Configuration.name=Completion Proposal Categories Configuration	32	Completion_Proposal_Categories_Configuration.name=Completion Proposal Categories Configuration
		33	Commenting_Strategy_Extension.name=Commenting Strategy Extension
33	##########################################################################	34	##########################################################################
34	# These strings are used in Workbench Keys Preferences	35	# These strings are used in Workbench Keys Preferences
35	##########################################################################	36	##########################################################################
36	scope.structuredTextEditor.name=Editing in Structured Text Editors	37	scope.structuredTextEditor.name=Editing in Structured Text Editors
37	scope.structuredTextEditor.description=Editing in Structured Text Editors	38	scope.structuredTextEditor.description=Editing in Structured Text Editors
		39	scope.structuredTextEditor.comments.description=Source Comments in Structured Text Editors
		40	scope.structuredTextEditor.comments.name=Source Comments in Structured Text Editors
38	command.toggle.comment.name=Toggle Comment	41	command.toggle.comment.name=Toggle Comment
39	command.toggle.comment.description=Toggle Comment	42	command.toggle.comment.description=Toggle Comment
		43	command.toggle.comment.mnemonic=T
40	command.add.block.comment.name=Add Block Comment	44	command.add.block.comment.name=Add Block Comment
41	command.add.block.comment.description=Add Block Comment	45	command.add.block.comment.description=Add Block Comment
		46	command.add.block.comment.mnemonic=A
42	command.remove.block.comment.name=Remove Block Comment	47	command.remove.block.comment.name=Remove Block Comment
43	command.remove.block.comment.description=Remove Block Comment	48	command.remove.block.comment.description=Remove Block Comment
		49	command.remove.block.comment.mnemonic=R
44	command.cleanup.document.name=Cleanup Document...	50	command.cleanup.document.name=Cleanup Document...
45	command.cleanup.document.description=Cleanup document	51	command.cleanup.document.description=Cleanup document
46	command.cleanup.document.mnemonic=C	52	command.cleanup.document.mnemonic=C

Added Link Here

(-)src/org/eclipse/wst/sse/ui/internal/handlers/AbstractCommentHandler.java (+96 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*
11	*******************************************************************************/
12	package org.eclipse.wst.sse.ui.internal.handlers;
13
14	import org.eclipse.core.commands.AbstractHandler;
15	import org.eclipse.core.commands.ExecutionEvent;
16	import org.eclipse.core.commands.ExecutionException;
17	import org.eclipse.jface.text.IDocument;
18	import org.eclipse.jface.text.ITextSelection;
19	import org.eclipse.jface.text.TextSelection;
20	import org.eclipse.jface.viewers.ISelection;
21	import org.eclipse.jface.viewers.ISelectionProvider;
22	import org.eclipse.ui.IEditorPart;
23	import org.eclipse.ui.handlers.HandlerUtil;
24	import org.eclipse.ui.texteditor.ITextEditor;
25	import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
26
27	/**
28	* This class contains all of the shared functionality for comment handlers
29	*/
30	public abstract class AbstractCommentHandler extends AbstractHandler {
31
32	/**
33	* <p>Default constructor must exist because sub classes are created by java reflection</p>
34	*/
35	public AbstractCommentHandler() {
36	super();
37	}
38
39	/**
40	* <p>Gets the important information out of the event and passes it onto
41	* the internal method {@link #processAction}</p>
42	*
43	* @see org.eclipse.wst.xml.ui.internal.handlers.CommentHandler#execute(org.eclipse.core.commands.ExecutionEvent)
44	*/
45	public final Object execute(ExecutionEvent event) throws ExecutionException {
46	IEditorPart editor = HandlerUtil.getActiveEditor(event);
47	ITextEditor textEditor = null;
48	if (editor instanceof ITextEditor)
49	textEditor = (ITextEditor) editor;
50	else {
51	Object o = editor.getAdapter(ITextEditor.class);
52	if (o != null)
53	textEditor = (ITextEditor) o;
54	}
55	if (textEditor != null) {
56	IDocument document = textEditor.getDocumentProvider().getDocument(textEditor.getEditorInput());
57	if (document != null && document instanceof IStructuredDocument) {
58	// get current text selection
59	ITextSelection textSelection = getCurrentSelection(textEditor);
60	if (!textSelection.isEmpty()) {
61	//call the implementers code to deal with the event
62	processAction(textEditor, (IStructuredDocument)document, textSelection);
63	}
64	}
65	}
66	return null;
67	}
68
69	/**
70	* <p>This method is called by the public {@link #execute} method whenever
71	* the comment handler is invoked. This method should be used for the
72	* logic of handling the structured comment event.</p>
73	*
74	* @param textEditor the text editor the initiating event was caused in
75	* @param document the document the text editor is editing
76	* @param textSelection the user selection when the event was caused
77	*/
78	protected abstract void processAction(ITextEditor textEditor, IStructuredDocument document, ITextSelection textSelection);
79
80	/**
81	* <p>Gets the current user selection in the given {@link ITextEditor}</p>
82	*
83	* @param textEditor get the user selection from here
84	* @return the current user selection in <code>textEdtior</code>
85	*/
86	private static ITextSelection getCurrentSelection(ITextEditor textEditor) {
87	ISelectionProvider provider = textEditor.getSelectionProvider();
88	if (provider != null) {
89	ISelection selection = provider.getSelection();
90	if (selection instanceof ITextSelection) {
91	return (ITextSelection) selection;
92	}
93	}
94	return TextSelection.emptySelection();
95	}
96	}

Added Link Here

(-)src/org/eclipse/wst/sse/ui/internal/comment/LineCommentingStrategy.java (+83 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.wst.sse.ui.internal.comment;
12
13	import org.eclipse.jface.text.BadLocationException;
14	import org.eclipse.jface.text.IRegion;
15	import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
16
17	/**
18	* <p>Represents a Line Comment commenting strategy</p>
19	*/
20	public class LineCommentingStrategy extends CommentingStrategy {
21	/** the prefix of the line comment associated with this strategy */
22	private String fPrefix;
23
24	/**
25	* @param prefix the prefix of the line comment associated with this strategy
26	*/
27	public LineCommentingStrategy(String prefix) {
28	super();
29	this.fPrefix = prefix;
30	}
31
32	/**
33	* <p>Assumes that the given offset is at the begining of a line and adds the line
34	* comment prefix there</p>
35	*
36	* @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#apply(
37	* org.eclipse.wst.sse.core.internal.provisional.IStructuredModel, int, int)
38	*/
39	public void apply(IStructuredDocument document, int offset, int length)
40	throws BadLocationException {
41
42	document.replace(offset, 0, this.fPrefix + " ");
43	}
44
45	/**
46	* <p>Assumes that the given offset is at the beginning of a line that is commented and removes
47	* the comment prefix from the beginning of the line, leading whitespace on the line will not
48	* prevent this method from finishing correctly</p>
49	*
50	* @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#remove(
51	* org.eclipse.wst.sse.core.internal.provisional.IStructuredModel, int, int, boolean)
52	*/
53	public void remove(IStructuredDocument document, int offset, int length, boolean removeEnclosing) throws BadLocationException{
54	String content = document.get(offset, length);
55	int innerOffset = content.indexOf(this.fPrefix);
56	if(innerOffset > 0) {
57	offset += innerOffset;
58	}
59
60	uncomment(document, offset, this.fPrefix, -1, null);
61	}
62
63	/**
64	* <p>A region is already commented if it begins with the the associated prefix ignoring any
65	* leading whitespace</p>
66	*
67	* @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#alreadyCommenting(
68	* org.eclipse.jface.text.IDocument, org.eclipse.jface.text.IRegion)
69	*/
70	public boolean alreadyCommenting(IStructuredDocument document, IRegion region)
71	throws BadLocationException {
72
73	String regionContent = document.get(region.getOffset(), region.getLength()).trim();
74	return regionContent.startsWith(this.fPrefix);
75	}
76
77	/**
78	* @see org.eclipse.wst.sse.ui.internal.comment.CommentingStrategy#clone()
79	*/
80	public Object clone() {
81	return new LineCommentingStrategy(this.fPrefix);
82	}
83	}

Added Link Here

(-)schema/commentingStrategy.exsd (+267 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.wst.sse.ui" xmlns="http://www.w3.org/2001/XMLSchema">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.wst.sse.ui" id="commentingStrategy" name="Commenting Strategy"/>
7	</appInfo>
8	<documentation>
9	This extension point allows the contribution of commenting strategy's to participate in the commenting actions, such as adding and removing commenting blocks and toggling line comments.
10	</documentation>
11	</annotation>
12
13	<element name="extension">
14	<annotation>
15	<appInfo>
16	<meta.element />
17	</appInfo>
18	</annotation>
19	<complexType>
20	<sequence>
21	<choice minOccurs="1" maxOccurs="unbounded">
22	<element ref="blockCommentingStrategy" minOccurs="0" maxOccurs="unbounded"/>
23	<element ref="lineCommentingStrategy" minOccurs="0" maxOccurs="unbounded"/>
24	</choice>
25	</sequence>
26	<attribute name="point" type="string" use="required">
27	<annotation>
28	<documentation>
29
30	</documentation>
31	</annotation>
32	</attribute>
33	<attribute name="id" type="string">
34	<annotation>
35	<documentation>
36	an optional identifier of the extension instance
37	</documentation>
38	</annotation>
39	</attribute>
40	<attribute name="name" type="string">
41	<annotation>
42	<documentation>
43
44	</documentation>
45	<appInfo>
46	<meta.attribute translatable="true"/>
47	</appInfo>
48	</annotation>
49	</attribute>
50	</complexType>
51	</element>
52
53	<element name="blockCommentingStrategy">
54	<annotation>
55	<documentation>
56	Defines a block commenting strategy
57	</documentation>
58	</annotation>
59	<complexType>
60	<sequence minOccurs="1" maxOccurs="unbounded">
61	<element ref="contentType"/>
62	</sequence>
63	<attribute name="prefix" type="string" use="required">
64	<annotation>
65	<documentation>
66	The prefix of the block comment this strategy impliments
67	</documentation>
68	</annotation>
69	</attribute>
70	<attribute name="suffix" type="string" use="required">
71	<annotation>
72	<documentation>
73	The suffix of the block comment this strategy impliments
74	</documentation>
75	</annotation>
76	</attribute>
77	</complexType>
78	</element>
79
80	<element name="lineCommentingStrategy">
81	<annotation>
82	<documentation>
83	Deefines a line commenting strategy
84	</documentation>
85	</annotation>
86	<complexType>
87	<sequence minOccurs="1" maxOccurs="unbounded">
88	<element ref="contentType"/>
89	</sequence>
90	<attribute name="prefix" type="string" use="required">
91	<annotation>
92	<documentation>
93	The prefix of the block comment this strategy impliments
94	</documentation>
95	</annotation>
96	</attribute>
97	</complexType>
98	</element>
99
100	<element name="contentType">
101	<annotation>
102	<documentation>
103	A content type that the strategy is applicable for
104	</documentation>
105	</annotation>
106	<complexType>
107	<sequence>
108	<choice>
109	<element ref="requiredPartitionTypes"/>
110	<element ref="allowablePartitionTypes"/>
111	<sequence>
112	<element ref="requiredPartitionTypes"/>
113	<element ref="allowablePartitionTypes"/>
114	</sequence>
115	</choice>
116	</sequence>
117	<attribute name="id" type="string" use="required">
118	<annotation>
119	<documentation>
120	The ID of the content type
121	</documentation>
122	<appInfo>
123	<meta.attribute kind="identifier" basedOn="org.eclipse.core.contenttype.contentTypes/content-type/@id"/>
124	</appInfo>
125	</annotation>
126	</attribute>
127	<attribute name="associatedCommentPartitionTypeID" type="string">
128	<annotation>
129	<documentation>
130	The partition type ID of the comment partition that is associated with the strategy in this content type
131	</documentation>
132	</annotation>
133	</attribute>
134	</complexType>
135	</element>
136
137	<element name="requiredPartitionTypes">
138	<annotation>
139	<documentation>
140	List of partition types in the associated content type that are requried for the strategy to be applicable. Depending on the value of the <code>requireAll</code> attribute either all or only at least one of these partition types must be present in a selection for the strategy to be applicable.
141	</documentation>
142	</annotation>
143	<complexType>
144	<sequence minOccurs="1" maxOccurs="unbounded">
145	<element ref="partitionType"/>
146	</sequence>
147	<attribute name="requireAll" type="boolean" use="default" value="false">
148	<annotation>
149	<documentation>
150	If <code>true</code> then all of the required partition types must be present in a user selection for the strategy to be valid, if <code>false</code> only at least one of the required partition types must be present in the a user selection for the strategy to be valid. These conditions are shortucted if the <code>associatedCommentPartitiontTypeID</code> for the <code>contentType</code> that thes required partition types are associated with is present in the user selection
151	</documentation>
152	</annotation>
153	</attribute>
154	</complexType>
155	</element>
156
157	<element name="allowablePartitionTypes">
158	<annotation>
159	<documentation>
160	The partition types that are allowed in a user selection for the strategy to be valid. It is assumed that any partition types listed in the <code>requiredPartitionTypes</code> are also allowable. This list is ignored if the value of <code>anyPartitionType</code> is <code>true</code>. If this list is not provided then it is assumed the value of <code>anyPartitionType</code> is false.
161	</documentation>
162	</annotation>
163	<complexType>
164	<sequence minOccurs="0" maxOccurs="unbounded">
165	<element ref="partitionType"/>
166	</sequence>
167	<attribute name="anyPartitionType" type="boolean" use="default" value="false">
168	<annotation>
169	<documentation>
170	If <code>true</code> then the strategy is valid for any partition type in the associated <code>contentType</code>, this means that any <code>partionType</code>s listed here would be ignored. If <code>false</code> then only the <code>partitionType</code>s listed here are allowed in a user selection (allong with any specified requried partition types) for the strategy to be valid.
171	</documentation>
172	</annotation>
173	</attribute>
174	</complexType>
175	</element>
176
177	<element name="partitionType">
178	<annotation>
179	<documentation>
180	A partition type associated with the parenting content type
181	</documentation>
182	</annotation>
183	<complexType>
184	<attribute name="id" type="string" use="required">
185	<annotation>
186	<documentation>
187	The ID of the partition type.
188	</documentation>
189	</annotation>
190	</attribute>
191	</complexType>
192	</element>
193
194
195	<annotation>
196	<appInfo>
197	<meta.section type="examples"/>
198	</appInfo>
199	<documentation>
200	<p><b>Example 1:</b> A simple example for block comments on XML documents</p><pre><extension point="org.eclipse.wst.sse.ui.commentingStrategy">
201	<blockCommentingStrategy
202	prefix="&lt;!--"
203	suffix="--&gt;">
204	<contentType
205	id="org.eclipse.core.runtime.xml"
206	associatedCommentPartitionTypeID="org.eclipse.wst.xml.XML_COMMENT">
207	<allowablePartitionTypes
208	anyPartitionType="true">
209	</allowablePartitionTypes>
210	</contentType>
211	</blockCommentingStrategy>
212	</extension></pre>
213
214	<p><b>Example 2:</b> A more complex example for adding CSS comenting to both CSS and HTML documents</p><pre><extension point="org.eclipse.wst.sse.ui.commentingStrategy">
215	<blockCommentingStrategy
216	prefix="/*"
217	suffix="*/">
218	<contentType
219	associatedCommentPartitionTypeID="org.eclipse.wst.css.COMMENT"
220	id="org.eclipse.wst.css.core.csssource">
221	<allowablePartitionTypes
222	anyPartitionType="true">
223	</allowablePartitionTypes>
224	</contentType>
225	<contentType
226	id="org.eclipse.wst.html.core.htmlsource">
227	<allowablePartitionTypes
228	anyPartitionType="false">
229	</allowablePartitionTypes>
230	<requiredPartitionTypes
231	requireAll="true">
232	<partitionType
233	id="org.eclipse.wst.css.STYLE">
234	</partitionType>
235	</requiredPartitionTypes>
236	</contentType>
237	</blockCommentingStrategy>
238	</extension></pre>
239	</documentation>
240	</annotation>
241
242	<annotation>
243	<appInfo>
244	<meta.section type="apiinfo"/>
245	</appInfo>
246	<documentation>
247	The user of this extension point does not need to impliment any classes themselves but for their contributions to work in any given content type then the following handlers must be registered for the content type in question by using the <code>org.eclipse.ui.handlers</code> extension point.
248	<ul>
249	<li><code>org.eclipse.wst.sse.ui.handlers.AddBlockCommentHandler</code></li>
250	<li><code>org.eclipse.wst.sse.ui.handlers.RemoveBlockCommentHandler</code></li>
251	<li><code>org.eclipse.wst.sse.ui.handlers.ToggleLineCommentHandler</code></li>
252	</ul>
253	</documentation>
254	</annotation>
255
256
257	<annotation>
258	<appInfo>
259	<meta.section type="copyright"/>
260	</appInfo>
261	<documentation>
262	Copyright (c) 2010 IBM Corporation and others.
263	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 <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
264	</documentation>
265	</annotation>
266
267	</schema>