/*******************************************************************************
* Copyright (c) 2014, 2015 Cisco Systems, Inc. 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
*
*******************************************************************************/
package com.cisco.yangide.editor.actions;
import java.util.Iterator;
import java.util.List;
import java.util.ResourceBundle;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.BadPartitioningException;
import org.eclipse.jface.text.BadPositionCategoryException;
import org.eclipse.jface.text.DefaultPositionUpdater;
import org.eclipse.jface.text.DocumentEvent;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentExtension3;
import org.eclipse.jface.text.IPositionUpdater;
import org.eclipse.jface.text.IRewriteTarget;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.ui.texteditor.ITextEditorExtension2;
import org.eclipse.ui.texteditor.TextEditorAction;
/**
* Common block comment code.
*
* @author Alexey Kholupko
*/
public abstract class BlockCommentAction extends TextEditorAction {
/**
* Creates a new instance.
*
* @param bundle
* @param prefix
* @param editor
*/
public BlockCommentAction(ResourceBundle bundle, String prefix, ITextEditor editor) {
super(bundle, prefix, editor);
}
/**
* An edit is a kind of <code>DocumentEvent</code>, an edit instruction, that is affiliated with
* a position on a document.
*/
static class Edit extends DocumentEvent {
/**
* Factory for edits which manages the creation, installation and destruction of position
* categories, position updaters etc. on a certain document.
*/
public static class EditFactory {
/** The position category basename for this edits. */
private static final String CATEGORY = "__positionalEditPositionCategory"; //$NON-NLS-1$
/** The count of factories. */
private static int fgCount = 0;
/** This factory's category. */
private final String fCategory;
private IDocument fDocument;
private IPositionUpdater fUpdater;
/**
* Creates a new <code>EditFactory</code> with an unambiguous position category name.
*
* @param document the document that is being edited.
*/
public EditFactory(IDocument document) {
fCategory = CATEGORY + fgCount++;
fDocument = document;
}
/**
* Creates a new edition on the document of this factory.
*
* @param offset the offset of the edition at the point when is created.
* @param length the length of the edition (not updated via the position update
* mechanism)
* @param text the text to be replaced on the document
* @return an <code>Edit</code> reflecting the edition on the document
*/
public Edit createEdit(int offset, int length, String text) throws BadLocationException {
if (!fDocument.containsPositionCategory(fCategory)) {
fDocument.addPositionCategory(fCategory);
fUpdater = new DefaultPositionUpdater(fCategory);
fDocument.addPositionUpdater(fUpdater);
}
Position position = new Position(offset);
try {
fDocument.addPosition(fCategory, position);
} catch (BadPositionCategoryException e) {
Assert.isTrue(false);
}
return new Edit(fDocument, length, text, position);
}
/**
* Releases the position category on the document and uninstalls the position updater.
* <code>Edit</code>s managed by this factory are not updated after this call.
*/
public void release() {
if (fDocument != null && fDocument.containsPositionCategory(fCategory)) {
fDocument.removePositionUpdater(fUpdater);
try {
fDocument.removePositionCategory(fCategory);
} catch (BadPositionCategoryException e) {
Assert.isTrue(false);
}
fDocument = null;
fUpdater = null;
}
}
}
/** The position in the document where this edit be executed. */
private Position fPosition;
/**
* Creates a new edition on <code>document</code>, taking its offset from
* <code>position</code>.
*
* @param document the document being edited
* @param length the length of the edition
* @param text the replacement text of the edition
* @param position the position keeping the edition's offset
*/
protected Edit(IDocument document, int length, String text, Position position) {
super(document, 0, length, text);
fPosition = position;
}
/*
* @see org.eclipse.jface.text.DocumentEvent#getOffset()
*/
@Override
public int getOffset() {
return fPosition.getOffset();
}
/**
* Executes the edition on document. The offset is taken from the position.
*
* @throws BadLocationException if the execution of the document fails.
*/
public void perform() throws BadLocationException {
getDocument().replace(getOffset(), getLength(), getText());
}
}
@Override
public void run() {
if (!isEnabled())
return;
ITextEditor editor = getTextEditor();
if (editor == null || !ensureEditable(editor))
return;
ITextSelection selection = getCurrentSelection();
if (!isValidSelection(selection))
return;
if (!validateEditorInputState())
return;
IDocumentProvider docProvider = editor.getDocumentProvider();
IEditorInput input = editor.getEditorInput();
if (docProvider == null || input == null)
return;
IDocument document = docProvider.getDocument(input);
if (document == null)
return;
IDocumentExtension3 docExtension;
if (document instanceof IDocumentExtension3)
docExtension = (IDocumentExtension3) document;
else
return;
IRewriteTarget target = (IRewriteTarget) editor.getAdapter(IRewriteTarget.class);
if (target != null) {
target.beginCompoundChange();
}
Edit.EditFactory factory = new Edit.EditFactory(document);
try {
runInternal(selection, docExtension, factory);
} catch (BadLocationException e) {
// can happen on concurrent modification, deletion etc. of the document
// -> don't complain, just bail out
} catch (BadPartitioningException e) {
// should not happen
Assert.isTrue(false, "bad partitioning"); //$NON-NLS-1$
} finally {
factory.release();
if (target != null) {
target.endCompoundChange();
}
}
}
/**
* Calls <code>perform</code> on all <code>Edit</code>s in <code>edits</code>.
*
* @param edits a list of <code>Edit</code>s
* @throws BadLocationException if an <code>Edit</code> threw such an exception.
*/
protected void executeEdits(List<Edit> edits) throws BadLocationException {
for (Iterator<Edit> it = edits.iterator(); it.hasNext();) {
Edit edit = it.next();
edit.perform();
}
}
/**
* Ensures that the editor is modifyable.
*/
protected boolean ensureEditable(ITextEditor editor) {
Assert.isNotNull(editor);
if (editor instanceof ITextEditorExtension2) {
ITextEditorExtension2 ext = (ITextEditorExtension2) editor;
return ext.validateEditorInputState();
}
return editor.isEditable();
}
/*
* @see org.eclipse.ui.texteditor.IUpdate#update()
*/
@Override
public void update() {
super.update();
if (isEnabled()) {
if (!canModifyEditor() || !isValidSelection(getCurrentSelection()))
setEnabled(false);
}
}
/**
* Returns the editor's selection, or <code>null</code> if no selection can be obtained or the
* editor is <code>null</code>.
*
* @return the selection of the action's editor, or <code>null</code>
*/
protected ITextSelection getCurrentSelection() {
ITextEditor editor = getTextEditor();
if (editor != null) {
ISelectionProvider provider = editor.getSelectionProvider();
if (provider != null) {
ISelection selection = provider.getSelection();
if (selection instanceof ITextSelection)
return (ITextSelection) selection;
}
}
return null;
}
/**
* Runs the real command once all the editor, document, and selection checks have succeeded.
*
* @param selection the current selection we are being called for
* @param docExtension the document extension where we get the partitioning from
* @param factory the edit factory we can use to create <code>Edit</code>s
* @throws BadLocationException if an edition fails
* @throws BadPartitioningException if a partitioning call fails
*/
protected abstract void runInternal(ITextSelection selection, IDocumentExtension3 docExtension,
Edit.EditFactory factory) throws BadLocationException, BadPartitioningException;
/**
* Checks whether <code>selection</code> is valid.
*
* @param selection the selection to check
* @return <code>true</code> if the selection is valid, <code>false</code> otherwise
*/
protected abstract boolean isValidSelection(ITextSelection selection);
/**
* @return the text to be inserted at the selection start
*/
protected String getCommentStart() {
// for now: no space story
return "/*"; //$NON-NLS-1$
}
/**
* @return the text to be inserted at the selection end
*/
protected String getCommentEnd() {
// for now: no space story
return "*/"; //$NON-NLS-1$
}
}