DocumentEvent, in this case an edit
+ * instruction, that is affilitated with a Position on a
+ * document. The offset of the document event is not stored statically, but
+ * taken from the affiliated Position, which gets updated
+ * when other edits occurr.
+ */
+ 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. Once a factory has been obtained, Edit
+ * objects can be obtained from it which will be linked to the document
+ * by positions of one position category.
+ *
+ * Clients are required to call release once the
+ * Edits are not used any more, so the positions can be
+ * discarded.
+ *
EditFactory 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 Edit 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. Edits 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 document, taking its offset
+ * from position.
+ *
+ * @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()
+ */
+ 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());
+ }
+
+ }
+
+ 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 perform on all Edits in
+ * edits.
+ *
+ * @param edits
+ * a list of Edits
+ * @throws BadLocationException
+ * if an Edit threw such an exception.
+ */
+ protected void executeEdits(List edits) throws BadLocationException {
+ for (Iterator it = edits.iterator(); it.hasNext();) {
+ Edit edit = (Edit) it.next();
+ edit.perform();
+ }
+ }
+
+ /**
+ * Ensures that the editor is modifyable. If the editor is an instance of
+ * ITextEditorExtension2, its
+ * validateEditorInputState method is called, otherwise, the
+ * result of isEditable is returned.
+ *
+ * @param editor
+ * the editor to be checked
+ * @return true if the editor is editable, false
+ * otherwise
+ */
+ 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()
+ */
+ public void update() {
+ super.update();
+
+ if (isEnabled()) {
+ if (!canModifyEditor() || !isValidSelection(getCurrentSelection()))
+ setEnabled(false);
+ }
+ }
+
+ /**
+ * Returns the editor's selection, or null if no selection
+ * can be obtained or the editor is null.
+ *
+ * @return the selection of the action's editor, or null
+ */
+ 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 Edits
+ * @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 selection is valid.
+ *
+ * @param selection
+ * the selection to check
+ * @return true if the selection is valid, false
+ * otherwise
+ */
+ protected abstract boolean isValidSelection(ITextSelection selection);
+
+ /**
+ * Returns the text to be inserted at the selection start.
+ *
+ * @return the text to be inserted at the selection start
+ */
+ protected String getCommentStart() {
+ // for now: no space story
+ return "/*"; //$NON-NLS-1$
+ }
+
+ /**
+ * Returns the text to be inserted at the selection end.
+ *
+ * @return the text to be inserted at the selection end
+ */
+ protected String getCommentEnd() {
+ // for now: no space story
+ return "*/"; //$NON-NLS-1$
+ }
+
+}