297 lines
8.8 KiB
Java
Executable File
297 lines
8.8 KiB
Java
Executable File
package pyUML.backend;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.IOException;
|
|
import java.io.InputStreamReader;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.Vector;
|
|
|
|
import org.eclipse.core.resources.IFile;
|
|
import org.eclipse.core.resources.IFolder;
|
|
import org.eclipse.core.resources.IProject;
|
|
import org.eclipse.core.resources.IResource;
|
|
import org.eclipse.core.resources.ResourcesPlugin;
|
|
import org.eclipse.core.runtime.CoreException;
|
|
import org.eclipse.core.runtime.IPath;
|
|
import org.eclipse.core.runtime.Path;
|
|
import org.eclipse.jface.dialogs.MessageDialog;
|
|
import org.eclipse.swt.widgets.Shell;
|
|
import org.eclipse.ui.IEditorReference;
|
|
import org.eclipse.ui.IWorkbenchPage;
|
|
import org.eclipse.ui.PlatformUI;
|
|
import org.python.pydev.plugin.nature.PythonNature;
|
|
|
|
/**
|
|
* Some Helper methods for Eclipse-specific tasks
|
|
*/
|
|
public class EclipseHelperMethods {
|
|
|
|
/**
|
|
* Closes an open Editor, if it is already opened
|
|
* @param project the current project
|
|
* @param editorName the Name of the editor to close (or a REGEX)
|
|
* @return true, if an editor was closed, false, if nothing was done
|
|
*/
|
|
public static boolean closeEditorByName(IProject project, String editorName){
|
|
IEditorReference editor = firstOpenEditorByName(editorName);
|
|
if (editor == null)
|
|
return false;
|
|
IWorkbenchPage page =
|
|
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
|
|
return page.closeEditor(editor.getEditor(true), true);
|
|
}
|
|
|
|
|
|
/**
|
|
* Looks for an open editor with a name that matches the given regex.
|
|
* Returns a list of matching editors or an empty list, if no such editor is open.
|
|
* @param editorNameRegex
|
|
* @return
|
|
*/
|
|
public static List<IEditorReference> lookForOpenEditorByName(String editorNameRegex) {
|
|
IWorkbenchPage page =
|
|
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
|
|
|
|
List<IEditorReference> editorList = new Vector<IEditorReference>();
|
|
for (IEditorReference editor : page.getEditorReferences()) {
|
|
if (editor.getTitle().matches(editorNameRegex)) {
|
|
editorList.add(editor);
|
|
}
|
|
}
|
|
return editorList;
|
|
}
|
|
|
|
/**
|
|
* Looks for an open editor with a name that matches the given regex.
|
|
* Returns the first matching editors or null, if no such editor is open.
|
|
* @param editorNameRegex
|
|
* @return
|
|
*/
|
|
public static IEditorReference firstOpenEditorByName(String editorNameRegex) {
|
|
List<IEditorReference> editorList = lookForOpenEditorByName(editorNameRegex);
|
|
if (editorList.size() == 0)
|
|
return null;
|
|
else
|
|
return editorList.get(0);
|
|
}
|
|
|
|
/**
|
|
* Reads the content of an IFile and returns teh String of the content
|
|
* @param file the IFile to read
|
|
* @return The file content String, null on error
|
|
*/
|
|
public static String iFileToString(IFile file){
|
|
String fileContents = "";
|
|
try{
|
|
BufferedReader reader = new BufferedReader(new InputStreamReader(file.getContents()));
|
|
String line;
|
|
while ((line = reader.readLine()) != null) {
|
|
fileContents+= line+"\n";
|
|
}
|
|
return fileContents;
|
|
}
|
|
catch (IOException e) {
|
|
MessageDialog.openError(null, "Error Reading File",
|
|
"Cannot Read file "+file+"\nReason:\n"+e.getMessage());
|
|
}
|
|
catch (CoreException e) {
|
|
MessageDialog.openError(null, "Error Reading File",
|
|
"Cannot Read file "+file+"\nReason:\n"+e.getMessage());
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Writes a string to an IFile. The old file content is replaced completely.
|
|
*
|
|
* @param file the IFile to update
|
|
* @param s the string to write to the file
|
|
* @return true on success, false otherwise
|
|
*/
|
|
public static boolean StringToIFile(IFile file, String s) {
|
|
try{
|
|
file.setContents(JavaHelperMethods.stringToStream(s),
|
|
IResource.FORCE, null);
|
|
EclipseHelperMethods.updateFile(file);
|
|
return true;
|
|
} catch (CoreException err) {
|
|
MessageDialog.openError(null, "Error writing file", err.getMessage());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* marks the ressource as updated in eclipse
|
|
* @param file the changed IFile
|
|
*/
|
|
public static void updateFile(IFile file) {
|
|
try {
|
|
file.refreshLocal(1, null);
|
|
} catch (CoreException e) {
|
|
System.out.println("Error updating ressource "+file.getName());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* marks the resource as updated in eclipse
|
|
* @param path the full path of the changed file
|
|
*/
|
|
public static void updateFile(String path, IProject project) {
|
|
try {
|
|
IFile file = createFile(path, project);
|
|
file.refreshLocal(1, null);
|
|
} catch (CoreException e) {
|
|
System.out.println("Error updating ressource "+path);
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* marks the folder as updated in eclipse
|
|
* @param path the full path of the changed file
|
|
*/
|
|
public static void updateFolder(String path, IProject project) {
|
|
try {
|
|
IFolder file = createFolder(path, project);
|
|
file.refreshLocal(IResource.DEPTH_INFINITE, null);
|
|
} catch (CoreException e) {
|
|
System.out.println("Error updating folder "+path);
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* creates an IFile resource out of an absolute Path and a project
|
|
* (the file is not created on the file system, only an IFile Object
|
|
* with appropriate path is created)
|
|
*/
|
|
public static IFile createFile(String path, IProject project) {
|
|
// cut everything in front of project name
|
|
String localPath = path.replace(project.getLocation().toOSString(), "");
|
|
IPath relativeFilePath = project.getFullPath().append(localPath);
|
|
return project.getWorkspace().getRoot().getFile(relativeFilePath);
|
|
}
|
|
|
|
/**
|
|
* creates an IFolder resource out of an absolute Path and a project
|
|
* (the folder is not created on the file system, only an IFolder Object
|
|
* with appropriate path is created)
|
|
*/
|
|
public static IFolder createFolder(String path, IProject project) {
|
|
// cut everything in front of project name
|
|
String localPath = path.replace(project.getLocation().toOSString(), "");
|
|
IPath relativeFilePath = project.getFullPath().append(localPath);
|
|
return project.getWorkspace().getRoot().getFolder(relativeFilePath);
|
|
}
|
|
|
|
|
|
/**
|
|
* Saves all Editors opened in the Workbench.
|
|
*/
|
|
public static void saveAllOpenEditors() {
|
|
// save all open editors
|
|
// (this may fail if the process is forked)
|
|
// (-> catch NullpointerException and do not save, then)
|
|
try {
|
|
IWorkbenchPage page =
|
|
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
|
|
page.saveAllEditors(false);
|
|
} catch (NullPointerException e) {}
|
|
}
|
|
|
|
|
|
|
|
public static boolean isPythonProject(IProject project) {
|
|
PythonNature store = new PythonNature();
|
|
store.setProject(project);
|
|
try {
|
|
store.getPythonPathNature().getProjectSourcePathSet(false);
|
|
} catch (CoreException e) {
|
|
return false;
|
|
}
|
|
catch (NullPointerException e) {
|
|
return false;
|
|
}
|
|
catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Finds the source folder(s) of this python project.
|
|
* If an error occurs (e.g. the project is no python
|
|
* project), the project location is returned.
|
|
* Source folders contained in other source folders are
|
|
* removed from list.
|
|
*
|
|
* @param project
|
|
* @return
|
|
*/
|
|
public static Set<IPath> getPythonSrcDirs(IProject project) {
|
|
PythonNature store = new PythonNature();
|
|
store.setProject(project);
|
|
Set<IPath> srcPaths = new HashSet<IPath>();
|
|
Set<String> srcStrings = null;
|
|
try {
|
|
srcStrings = store.getPythonPathNature().getProjectSourcePathSet(true);
|
|
}
|
|
catch (CoreException e) {
|
|
srcPaths.add(project.getLocation());
|
|
return srcPaths;
|
|
}
|
|
catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
srcDirLoop:
|
|
for (String dirString : srcStrings) {
|
|
|
|
// continue, if this dir is already contained in any other dir
|
|
for (String dirString2 : srcStrings) {
|
|
if (dirString != dirString2 && dirString2.startsWith(dirString))
|
|
continue srcDirLoop;
|
|
}
|
|
|
|
IPath srcPath = new Path(dirString);
|
|
IPath srcDir = srcPath.removeFirstSegments(1); //remove project dir
|
|
IPath completeSrcPath = project.getLocation().append(srcDir);
|
|
srcPaths.add(completeSrcPath);
|
|
}
|
|
|
|
return srcPaths;
|
|
|
|
}
|
|
|
|
/**
|
|
* This method chooses from the list of available Projects
|
|
* in the Workspace the project to work with, which is
|
|
* -> a python project
|
|
* -> if there are several, the user us asked which one to use
|
|
* -> if there is no project selected, the user asked to select one
|
|
*
|
|
* @return the pyDev project that was selected
|
|
* null, if no project could be chosen
|
|
*/
|
|
public static IProject selectProject() {
|
|
IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
|
|
List<IProject> pyDevProjects = new Vector<IProject>();
|
|
// find all pyDev-Projects
|
|
for (IProject project : projects) {
|
|
if (project.isOpen() && isPythonProject(project))
|
|
pyDevProjects.add(project);
|
|
}
|
|
if (pyDevProjects.size() == 0)
|
|
return null;
|
|
|
|
if (pyDevProjects.size() == 1)
|
|
return (pyDevProjects.get(0));
|
|
|
|
// let user choose the project to use
|
|
return ChooseProjectDialog.runChooseProject((Shell) null, pyDevProjects);
|
|
}
|
|
}
|