Java tutorial
/******************************************************************************* * Copyright (c) 2010 Red Hat, Inc. * Distributed under license by Red Hat, Inc. All rights reserved. * This program is 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: * Red Hat, Inc. - initial API and implementation ******************************************************************************/ package org.jboss.tools.common.refactoring; import java.util.HashSet; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.eclipse.core.resources.IFile; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.jdt.core.Flags; import org.eclipse.jdt.core.IAnnotatable; import org.eclipse.jdt.core.IAnnotation; import org.eclipse.jdt.core.IBuffer; import org.eclipse.jdt.core.ICompilationUnit; import org.eclipse.jdt.core.IImportContainer; import org.eclipse.jdt.core.IImportDeclaration; import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.ILocalVariable; import org.eclipse.jdt.core.IMember; import org.eclipse.jdt.core.IMethod; import org.eclipse.jdt.core.IPackageDeclaration; import org.eclipse.jdt.core.IType; import org.eclipse.jdt.core.ITypeParameter; import org.eclipse.jdt.core.JavaModelException; import org.eclipse.jdt.core.dom.ASTNode; import org.eclipse.jdt.core.dom.BodyDeclaration; import org.eclipse.jdt.core.dom.CompilationUnit; import org.eclipse.jdt.internal.core.JavaElement; import org.eclipse.jdt.internal.corext.util.CodeFormatterUtil; import org.eclipse.jdt.internal.ui.JavaPlugin; import org.eclipse.jdt.internal.ui.text.correction.proposals.EditAnnotator; import org.eclipse.jface.text.IDocument; import org.eclipse.jpt.common.core.internal.utility.jdt.ASTTools; import org.eclipse.ltk.core.refactoring.Change; import org.eclipse.ltk.core.refactoring.CompositeChange; import org.eclipse.ltk.core.refactoring.TextChange; import org.eclipse.text.edits.DeleteEdit; import org.eclipse.text.edits.InsertEdit; import org.eclipse.text.edits.MultiTextEdit; import org.eclipse.text.edits.ReplaceEdit; import org.eclipse.text.edits.TextEdit; import org.eclipse.ui.IEditorInput; import org.eclipse.ui.IEditorPart; import org.eclipse.ui.IFileEditorInput; import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.IWorkbenchWindow; import org.eclipse.ui.PlatformUI; import org.jboss.tools.common.util.EclipseJavaUtil; public class MarkerResolutionUtils { public static final String DOT = "."; //$NON-NLS-1$ public static final String DOTS = "..."; //$NON-NLS-1$ public static final String COMMA = ","; //$NON-NLS-1$ public static final String SEMICOLON = ";"; //$NON-NLS-1$ public static final String SPACE = " "; //$NON-NLS-1$ public static final String AT = "@"; //$NON-NLS-1$ public static final String IMPLEMENTS = "implements"; //$NON-NLS-1$ public static final String IMPORT = "import"; //$NON-NLS-1$ public static final String STATIC = "static"; //$NON-NLS-1$ public static final String EXTENDS = "extends"; //$NON-NLS-1$ public static final String OPEN_BRACE = "{"; //$NON-NLS-1$ public static final String CLOSE_BRACE = "}"; //$NON-NLS-1$ public static final String OPEN_BOLD = "<b>"; //$NON-NLS-1$ public static final String CLOSE_BOLD = "</b>"; //$NON-NLS-1$ public static final String OPEN_DEL = "<del>"; //$NON-NLS-1$ public static final String CLOSE_DEL = "</del>"; //$NON-NLS-1$ public static final String NEW_LINE = "\n"; //$NON-NLS-1$ public static final String LINE_BREAK = "<br>"; //$NON-NLS-1$ public static final String PUBLIC = "public"; //$NON-NLS-1$ public static final String PRIVATE = "private"; //$NON-NLS-1$ public static final String PROTECTED = "protected"; //$NON-NLS-1$ public static final char C_SPACE = ' '; //$NON-NLS-1$ public static final char C_TAB = '\t'; public static final char C_CARRIAGE_RETURN = '\r'; public static final char C_NEW_LINE = '\n'; public static final HashSet<String> primitives = new HashSet<String>(); static { primitives.add("void"); //$NON-NLS-1$ primitives.add("int"); //$NON-NLS-1$ primitives.add("java.lang.Integer"); //$NON-NLS-1$ primitives.add("char"); //$NON-NLS-1$ primitives.add("java.lang.Character"); //$NON-NLS-1$ primitives.add("boolean"); //$NON-NLS-1$ primitives.add("java.lang.Boolean"); //$NON-NLS-1$ primitives.add("short"); //$NON-NLS-1$ primitives.add("java.lang.Short"); //$NON-NLS-1$ primitives.add("long"); //$NON-NLS-1$ primitives.add("java.lang.Long"); //$NON-NLS-1$ primitives.add("float"); //$NON-NLS-1$ primitives.add("java.lang.Float"); //$NON-NLS-1$ primitives.add("double"); //$NON-NLS-1$ primitives.add("java.lang.Double"); //$NON-NLS-1$ primitives.add("byte"); //$NON-NLS-1$ primitives.add("java.lang.Byte"); //$NON-NLS-1$ primitives.add("java.lang.String"); //$NON-NLS-1$ primitives.add("java.lang.SuppressWarnings"); //$NON-NLS-1$ } /** * * @param qualifiedName * @param compilationUnit * @return true if there is import in compilation unit with the same short name * @throws JavaModelException */ public static boolean addImport(String qualifiedName, ICompilationUnit compilationUnit) throws JavaModelException { return addImport(qualifiedName, compilationUnit, false, null); } public static boolean addImport(String qualifiedName, ICompilationUnit compilationUnit, MultiTextEdit rootEdit) throws JavaModelException { return addImport(qualifiedName, compilationUnit, false, rootEdit); } /** * * @param qualifiedName * @param compilationUnit * @param staticFlag * @return true if there is import in compilation unit with the same short name * @throws JavaModelException */ public static boolean addImport(String qualifiedName, ICompilationUnit compilationUnit, boolean staticFlag) throws JavaModelException { return addImport(qualifiedName, compilationUnit, staticFlag, null); } private static int findPositionForImport(ICompilationUnit compilationUnit) throws JavaModelException { if (compilationUnit.getImportContainer().exists()) { return compilationUnit.getImportContainer().getSourceRange().getOffset() + compilationUnit.getImportContainer().getSourceRange().getLength(); } else { IPackageDeclaration[] packageDeclarations = compilationUnit.getPackageDeclarations(); if (packageDeclarations.length == 0) { return 0; } int position = 0; for (IPackageDeclaration declaration : packageDeclarations) { position = declaration.getSourceRange().getOffset() + declaration.getSourceRange().getLength(); } return position; } } private static boolean isDuplicate(MultiTextEdit rootEdit, String text) { for (TextEdit edit : rootEdit.getChildren()) { if (edit instanceof InsertEdit && ((InsertEdit) edit).getText().equals(text)) return true; } return false; } public static boolean addImport(String qualifiedName, ICompilationUnit compilationUnit, boolean staticFlag, MultiTextEdit rootEdit) throws JavaModelException { if (primitives.contains(qualifiedName) || qualifiedName.indexOf(DOT) < 0) return false; if (qualifiedName != null) { String shortName = getShortName(qualifiedName); IPackageDeclaration[] packages = compilationUnit.getPackageDeclarations(); // local classes do not need to be imported String typePackage = qualifiedName.substring(0, qualifiedName.lastIndexOf(DOT)); for (IPackageDeclaration packageDeclaration : packages) { if (packageDeclaration.getElementName().equals(typePackage)) return false; } for (IPackageDeclaration packageDeclaration : packages) { IType type = compilationUnit.getJavaProject() .findType(packageDeclaration.getElementName() + DOT + shortName); if (type != null && type.exists()) return true; } IImportDeclaration[] importDeclarations = compilationUnit.getImports(); for (IImportDeclaration importDeclaration : importDeclarations) { String importName = importDeclaration.getElementName(); String elementShort = getShortName(importName); if (importDeclaration.isOnDemand()) { int importLastDot = importName.lastIndexOf(DOT); if (importLastDot == -1) return false; // invalid import declaration int elementLastDot = qualifiedName.lastIndexOf(DOT); if (elementLastDot == -1) return false; // invalid import declaration if (qualifiedName.substring(0, elementLastDot).equals(importName.substring(0, importLastDot))) return false; } if (importName.equals(qualifiedName)) return false; if (elementShort.equals(shortName)) return true; } if (rootEdit == null) { if (staticFlag) { compilationUnit.createImport(qualifiedName, null, Flags.AccStatic, new NullProgressMonitor()); } else { compilationUnit.createImport(qualifiedName, null, new NullProgressMonitor()); } } else { String staticStr = ""; if (staticFlag) { staticStr = STATIC + SPACE; } String text = compilationUnit.findRecommendedLineSeparator() + IMPORT + SPACE + staticStr + qualifiedName + SEMICOLON; if (!isDuplicate(rootEdit, text)) { int importPosition = findPositionForImport(compilationUnit); TextEdit edit = new InsertEdit(importPosition, text); rootEdit.addChild(edit); } } } return false; } public static String getShortName(String qualifiedName) { int lastDot = qualifiedName.lastIndexOf(DOT); String name; if (lastDot < 0) name = qualifiedName; else name = qualifiedName.substring(lastDot + 1); return name; } public static String getPackageName(String qualifiedName) { int lastDot = qualifiedName.lastIndexOf(DOT); String name; if (lastDot < 0) name = ""; else name = qualifiedName.substring(0, lastDot); return name; } public static String[] getShortNames(String[] qualifiedNames) { String[] shortNames = new String[qualifiedNames.length]; for (int i = 0; i < qualifiedNames.length; i++) { shortNames[i] = getShortName(qualifiedNames[i]); } return shortNames; } public static String getTotalList(String[] names) { String list = ""; for (int i = 0; i < names.length; i++) { if (i != 0) list += ", "; list += names[i]; } return list; } public static void addMethod(List<String> lines, ICompilationUnit compilationUnit, IType type, MultiTextEdit rootEdit) throws JavaModelException { IType workingCopyType = findWorkingCopy(compilationUnit, type); if (workingCopyType == null) { return; } IBuffer buffer = compilationUnit.getBuffer(); String lineSeparator = compilationUnit.findRecommendedLineSeparator(); int position = workingCopyType.getSourceRange().getOffset() + workingCopyType.getSource().lastIndexOf("}"); if (position > 0) { String spaces = getLeadingSpacesToInsert(position, buffer); int indentWidth = CodeFormatterUtil.getIndentWidth(compilationUnit.getJavaProject()); for (int i = 0; i < indentWidth; i++) { spaces += SPACE; } String text = lineSeparator; for (String line : lines) { text += spaces; text += line; text += lineSeparator; } if (rootEdit != null) { TextEdit edit = new InsertEdit(position, text); rootEdit.addChild(edit); } else { buffer.replace(position, 0, text); synchronized (compilationUnit) { compilationUnit.reconcile(ICompilationUnit.NO_AST, true, null, null); } } } } public static void addAnnotation(String qualifiedName, ICompilationUnit compilationUnit, IJavaElement element) throws JavaModelException { addAnnotation(qualifiedName, compilationUnit, element, ""); } public static void updateAnnotation(String qualifiedName, ICompilationUnit compilationUnit, IJavaElement element, String params) throws JavaModelException { updateAnnotation(qualifiedName, compilationUnit, element, params, null); } public static void updateAnnotation(String qualifiedName, ICompilationUnit compilationUnit, IJavaElement element, String params, MultiTextEdit rootEdit) throws JavaModelException { IJavaElement workingCopyElement = findWorkingCopy(compilationUnit, element); if (workingCopyElement == null) { return; } if (!(workingCopyElement instanceof IMember)) return; IMember workingCopyMember = (IMember) workingCopyElement; IAnnotation annotation = findAnnotation(workingCopyMember, qualifiedName); if (annotation == null || !annotation.exists()) return; boolean duplicateShortName = addImport(qualifiedName, compilationUnit, null); IBuffer buffer = compilationUnit.getBuffer(); String shortName = getShortName(qualifiedName); if (duplicateShortName) shortName = qualifiedName; String newValue = AT + shortName + params; if (!annotation.getSource().equals(newValue)) { if (rootEdit != null) { TextEdit edit = new ReplaceEdit(annotation.getSourceRange().getOffset(), annotation.getSourceRange().getLength(), newValue); rootEdit.addChild(edit); } else { buffer.replace(annotation.getSourceRange().getOffset(), annotation.getSourceRange().getLength(), newValue); synchronized (compilationUnit) { compilationUnit.reconcile(ICompilationUnit.NO_AST, true, null, null); } } } } public static void addAnnotation(String qualifiedName, ICompilationUnit compilationUnit, IJavaElement element, String params) throws JavaModelException { addAnnotation(qualifiedName, compilationUnit, element, params, null); } public static void addAnnotation(String qualifiedName, ICompilationUnit compilationUnit, IJavaElement element, String params, MultiTextEdit rootEdit) throws JavaModelException { IJavaElement workingCopyElement = findWorkingCopy(compilationUnit, element); if (workingCopyElement == null) { return; } if (!(workingCopyElement instanceof IMember)) return; IMember workingCopyMember = (IMember) workingCopyElement; IAnnotation annotation = findAnnotation(workingCopyMember, qualifiedName); if (annotation != null && annotation.exists()) return; CompilationUnit cuNode = ASTTools.buildASTRoot(compilationUnit); ASTNode elementNode = null; if (workingCopyElement instanceof JavaElement) { elementNode = ((JavaElement) workingCopyElement).findNode(cuNode); } boolean duplicateShortName = addImport(qualifiedName, compilationUnit, rootEdit); IBuffer buffer = compilationUnit.getBuffer(); String shortName = getShortName(qualifiedName); if (duplicateShortName) shortName = qualifiedName; String str = AT + shortName + params; int position = workingCopyMember.getSourceRange().getOffset(); if (elementNode != null) { position = elementNode.getStartPosition(); if (elementNode instanceof BodyDeclaration && ((BodyDeclaration) elementNode).getJavadoc() != null) { position += ((BodyDeclaration) elementNode).getJavadoc().getLength(); char c = buffer.getChar(position); while ((c == C_CARRIAGE_RETURN || c == C_NEW_LINE) && position < buffer.getLength() - 2) { position++; c = buffer.getChar(position); } } while (position < buffer.getLength() - 1) { char c = buffer.getChar(position); if (c != C_CARRIAGE_RETURN && c != C_NEW_LINE && c != C_SPACE && c != C_TAB) { break; } position++; } } if (!(workingCopyMember instanceof ILocalVariable)) { str += compilationUnit.findRecommendedLineSeparator(); str += getLeadingSpacesToInsert(position, buffer); } else { str += SPACE; } if (rootEdit != null) { TextEdit edit = new InsertEdit(position, str); rootEdit.addChild(edit); } else { buffer.replace(position, 0, str); synchronized (compilationUnit) { compilationUnit.reconcile(ICompilationUnit.NO_AST, true, null, null); } } } @SuppressWarnings("unchecked") public static <T extends IJavaElement> T findWorkingCopy(ICompilationUnit compilationUnit, T element) throws JavaModelException { if (element instanceof IAnnotation) { IJavaElement parent = findWorkingCopy(compilationUnit, element.getParent()); if (parent instanceof IAnnotatable) { for (IAnnotation a : ((IAnnotatable) parent).getAnnotations()) { if (a.getElementName().equals(element.getElementName())) return (T) a; } } } else if (element instanceof ILocalVariable && ((ILocalVariable) element).isParameter()) { IJavaElement parent = findWorkingCopy(compilationUnit, element.getParent()); if (parent instanceof IMethod) { for (ILocalVariable parameter : ((IMethod) parent).getParameters()) { if (parameter.getElementName().equals(element.getElementName()) && parameter.getTypeSignature().equals(((ILocalVariable) element).getTypeSignature())) return (T) parameter; } } } else { IJavaElement[] elements = compilationUnit.findElements(element); if (elements != null) { for (IJavaElement e : elements) { if (e.getHandleIdentifier().equals(element.getHandleIdentifier())) return (T) e; } } } return null; } public static IAnnotation findAnnotation(IJavaElement element, String qualifiedName) { if (element instanceof IAnnotatable) { String name = getShortName(qualifiedName); IAnnotation annotation = ((IAnnotatable) element).getAnnotation(qualifiedName); if (!annotation.exists()) { annotation = ((IAnnotatable) element).getAnnotation(name); } else { return annotation; } if (annotation.exists()) { IType type = null; if (element instanceof IType) { type = (IType) element; } else if (element instanceof IMember) { type = ((IMember) element).getDeclaringType(); } else if (element instanceof ITypeParameter) { type = ((ITypeParameter) element).getDeclaringMember().getDeclaringType(); } else if (element instanceof ILocalVariable) { type = ((ILocalVariable) element).getDeclaringMember().getDeclaringType(); } if (type != null && annotation != null && qualifiedName.equals(EclipseJavaUtil.resolveType(type, name))) { return annotation; } } } return null; } public static void addInterfaceToClass(ICompilationUnit compilationUnit, IType type, String qualifiedName, MultiTextEdit rootEdit) throws JavaModelException { String shortName = getShortName(qualifiedName); IType[] types = compilationUnit.getTypes(); IType workingType = null; for (IType t : types) { if (t.getElementName().equals(type.getElementName())) { workingType = t; break; } } if (workingType != null) { addImport(qualifiedName, compilationUnit, rootEdit); IBuffer buffer = compilationUnit.getBuffer(); String text = buffer.getText(workingType.getSourceRange().getOffset(), workingType.getSourceRange().getLength()); int namePosition = text.indexOf(workingType.getElementName()); if (namePosition >= 0) { int implementsPosition = text.indexOf(IMPLEMENTS, namePosition); if (implementsPosition > 0) { if (rootEdit != null) { TextEdit edit = new InsertEdit( workingType.getSourceRange().getOffset() + implementsPosition + IMPLEMENTS.length(), SPACE + shortName + COMMA); rootEdit.addChild(edit); } else { buffer.replace( workingType.getSourceRange().getOffset() + implementsPosition + IMPLEMENTS.length(), 0, SPACE + shortName + COMMA); } } else { int extedsPosition = text.indexOf(EXTENDS, namePosition); if (extedsPosition > 0) { int bracePosition = text.indexOf(OPEN_BRACE, extedsPosition); String str = IMPLEMENTS + SPACE + shortName + SPACE; if (!text.substring(bracePosition - 1, bracePosition).equals(SPACE)) str = SPACE + str; if (rootEdit != null) { TextEdit edit = new InsertEdit(workingType.getSourceRange().getOffset() + bracePosition, str); rootEdit.addChild(edit); } else { buffer.replace(workingType.getSourceRange().getOffset() + bracePosition, 0, str); } } else { if (rootEdit != null) { TextEdit edit = new InsertEdit( workingType.getSourceRange().getOffset() + namePosition + workingType.getElementName().length(), SPACE + IMPLEMENTS + SPACE + shortName); rootEdit.addChild(edit); } else { buffer.replace( workingType.getSourceRange().getOffset() + namePosition + workingType.getElementName().length(), 0, SPACE + IMPLEMENTS + SPACE + shortName); } } } } } } public static void deleteAnnotation(String qualifiedName, ICompilationUnit compilationUnit, IJavaElement element) throws JavaModelException { deleteAnnotation(qualifiedName, compilationUnit, element, null); } public static void deleteAnnotation(String qualifiedName, ICompilationUnit compilationUnit, IJavaElement element, MultiTextEdit rootEdit) throws JavaModelException { IJavaElement workingCopyElement = findWorkingCopy(compilationUnit, element); if (workingCopyElement == null) { return; } IAnnotation annotation = findAnnotation(workingCopyElement, qualifiedName); if (annotation != null) { IBuffer buffer = compilationUnit.getBuffer(); int numberOfSpaces = getNumberOfSpacesToDelete( annotation.getSourceRange().getOffset() + annotation.getSourceRange().getLength(), buffer); // delete annotation if (rootEdit != null) { TextEdit edit = new DeleteEdit(annotation.getSourceRange().getOffset(), annotation.getSourceRange().getLength() + numberOfSpaces); rootEdit.addChild(edit); } else { buffer.replace(annotation.getSourceRange().getOffset(), annotation.getSourceRange().getLength() + numberOfSpaces, ""); } // check and delete import deleteImportForAnnotation(qualifiedName, annotation, compilationUnit, buffer, rootEdit); } } private static int getNumberOfSpacesToDelete(int startPosition, IBuffer buffer) { int position = startPosition; int numberOfSpaces = 0; if (position < buffer.getLength() - 1) { char c = buffer.getChar(position); while ((c == C_SPACE || c == C_TAB || c == C_NEW_LINE || c == C_CARRIAGE_RETURN) && position < buffer.getLength() - 1) { numberOfSpaces++; position++; c = buffer.getChar(position); } } return numberOfSpaces; } private static String getLeadingSpacesToInsert(int startPosition, IBuffer buffer) { int position = startPosition; while (position >= 0) { char c = buffer.getChar(position); if (c == C_CARRIAGE_RETURN || c == C_NEW_LINE) break; position--; } position++; if (position != startPosition) { return buffer.getText(position, startPosition - position); } return ""; } public static void deleteImportForAnnotation(String qualifiedName, IAnnotation annotation, ICompilationUnit compilationUnit, IBuffer buffer, MultiTextEdit rootEdit) throws JavaModelException { IImportDeclaration importDeclaration = compilationUnit.getImport(qualifiedName); IImportContainer importContainer = compilationUnit.getImportContainer(); if (importDeclaration.exists() && importContainer.exists()) { int importSize = importContainer.getSourceRange().getOffset() + importContainer.getSourceRange().getLength(); if (rootEdit != null) { int annotationStart = annotation.getSourceRange().getOffset(); int annotationEnd = annotationStart + annotation.getSourceRange().getLength(); String textBefore = buffer.getText(importSize, annotationStart - importSize); String textAfter = buffer.getText(annotationEnd, buffer.getLength() - annotationEnd); if (checkImport(textBefore, qualifiedName) && checkImport(textAfter, qualifiedName)) { int numberOfSpaces = 0; if (!isLastImport(importContainer, importDeclaration)) { numberOfSpaces = getNumberOfSpacesToDelete(importDeclaration.getSourceRange().getOffset() + importDeclaration.getSourceRange().getLength(), buffer); } TextEdit edit = new DeleteEdit(importDeclaration.getSourceRange().getOffset(), importDeclaration.getSourceRange().getLength() + numberOfSpaces); rootEdit.addChild(edit); } } else { String text = buffer.getText(importSize, buffer.getLength() - importSize); if (checkImport(text, qualifiedName)) { importDeclaration.delete(false, new NullProgressMonitor()); } } } if (rootEdit == null) { synchronized (compilationUnit) { compilationUnit.reconcile(ICompilationUnit.NO_AST, true, null, null); } } } private static boolean isLastImport(IImportContainer importContainer, IImportDeclaration importDeclaration) throws JavaModelException { for (int index = 0; index < importContainer.getChildren().length; index++) { IJavaElement child = importContainer.getChildren()[index]; if (child.equals(importDeclaration) && index == importContainer.getChildren().length - 1) { return true; } } return false; } public static boolean checkImport(String text, String qualifiedName) { String name = getShortName(qualifiedName); Pattern p = Pattern.compile(".*\\W" + name + "\\W.*", Pattern.DOTALL); //$NON-NLS-1$ //$NON-NLS-2$ Matcher m = p.matcher(text); return !m.matches(); } public static IMember getJavaMember(IJavaElement element) { while (element != null) { if (element instanceof IMember) return (IMember) element; element = element.getParent(); } return null; } private static TextChange getTextChange(Change change) { if (change instanceof TextChange) { return (TextChange) change; } else if (change instanceof CompositeChange) { for (Change child : ((CompositeChange) change).getChildren()) { if (child instanceof TextChange) { return (TextChange) child; } } } return null; } @SuppressWarnings("restriction") public static String getPreview(Change original) throws CoreException { if (original == null) return null; StringBuffer buf = new StringBuffer(); try { TextChange change = getTextChange(original); if (change == null) { return ""; } change.setKeepPreviewEdits(true); IDocument previewDocument = change.getPreviewDocument(new NullProgressMonitor()); TextEdit rootEdit = change.getPreviewEdit(change.getEdit()); EditAnnotator ea = new EditAnnotator(buf, previewDocument); rootEdit.accept(ea); ea.unchangedUntil(previewDocument.getLength()); // Final pre-existing region } catch (CoreException e) { JavaPlugin.log(e); } return buf.toString(); } public static IFile getFile() { IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow(); if (window != null) { IWorkbenchPage page = window.getActivePage(); if (page != null) { IEditorPart editor = page.getActiveEditor(); if (editor != null) { IEditorInput input = editor.getEditorInput(); if (input instanceof IFileEditorInput) { return ((IFileEditorInput) input).getFile(); } } } } return null; } }