Java Code Examples for org.eclipse.core.resources.IContainer#isAccessible()

private void deleteMarkersRecursively(FileURI location) {
	if (location == null) {
		return;
	}

	IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
	IContainer[] containers = root.findContainersForLocationURI(URI.create(location.toString()));
	if (containers == null || containers.length == 0) {
		return;
	}

	try {
		for (IContainer container : containers) {
			if (container.isAccessible()) {
				container.deleteMarkers(null, true, IResource.DEPTH_INFINITE);
			}
		}
	} catch (CoreException e) {
		e.printStackTrace();
	}
}
 

@Override
public IStatus handlePluginTransferDrop(IStructuredSelection aDragSelection, Object aDropTarget) {
    aDropTarget = getActual(aDropTarget);

    IContainer target = getActualTarget((IResource) aDropTarget);
    IResource[] resources = getSelectedResources(aDragSelection);

    MoveFilesAndFoldersOperation operation = new MoveFilesAndFoldersOperation(getShell());
    operation.copyResources(resources, target);

    if (target != null && target.isAccessible()) {
        try {
            target.refreshLocal(IResource.DEPTH_ONE, null);
        } catch (CoreException e) {
        }
    }
    return Status.OK_STATUS;
}
 

public IStatus handlePluginTransferDrop(IStructuredSelection aDragSelection, Object aDropTarget) {

		IContainer target = getActualTarget((IResource) aDropTarget);
		IResource[] resources = getSelectedResources(aDragSelection);
		
		MoveFilesAndFoldersOperation operation = new MoveFilesAndFoldersOperation(
				 getShell());
		operation.copyResources(resources, target);

		if (target != null && target.isAccessible()) {
			try {
				target.refreshLocal(IResource.DEPTH_ONE, null);
			} catch (CoreException e) {
			}
		}
		return Status.OK_STATUS;
	}
 

public boolean hasChildren(Object element) {
	try {
		if (element instanceof IContainer) {
			IContainer c = (IContainer) element;
			if (!c.isAccessible())
				return false;
			return c.members().length > 0;
		}
	} catch (CoreException ex) {
		WorkbenchNavigatorPlugin.getDefault().getLog().log(
				new Status(IStatus.ERROR, WorkbenchNavigatorPlugin.PLUGIN_ID, 0, ex.getMessage(), ex));
		return false;
	}

	return super.hasChildren(element);
}
 

public IStatus handlePluginTransferDrop(IStructuredSelection aDragSelection, Object aDropTarget) {

		IContainer target = getActualTarget((IResource) aDropTarget);
		IResource[] resources = getSelectedResources(aDragSelection);
		
		MoveFilesAndFoldersOperation operation = new MoveFilesAndFoldersOperation(
				 getShell());
		operation.copyResources(resources, target);

		if (target != null && target.isAccessible()) {
			try {
				target.refreshLocal(IResource.DEPTH_ONE, null);
			} catch (CoreException e) {
			}
		}
		return Status.OK_STATUS;
	}
 

public boolean hasChildren(Object element) {
	try {
		if (element instanceof IContainer) {
			IContainer c = (IContainer) element;
			if (!c.isAccessible())
				return false;
			return c.members().length > 0;
		}
	} catch (CoreException ex) {
		WorkbenchNavigatorPlugin.getDefault().getLog().log(
				new Status(IStatus.ERROR, WorkbenchNavigatorPlugin.PLUGIN_ID, 0, ex.getMessage(), ex));
		return false;
	}

	return super.hasChildren(element);
}
 

/**
 * {@inheritDoc}
 */
@Override
protected int determineOperation(Object target, int operation, TransferData transferType, int operations) {

	boolean isPackageFragment= target instanceof IPackageFragment;
	boolean isJavaProject= target instanceof IJavaProject;
	boolean isPackageFragmentRoot= target instanceof IPackageFragmentRoot;
	boolean isContainer= target instanceof IContainer;

	if (!(isPackageFragment || isJavaProject || isPackageFragmentRoot || isContainer))
		return DND.DROP_NONE;

	if (isContainer) {
		IContainer container= (IContainer)target;
		if (container.isAccessible() && !Resources.isReadOnly(container))
			return DND.DROP_COPY;
	} else {
		IJavaElement element= (IJavaElement)target;
		if (!element.isReadOnly())
			return DND.DROP_COPY;
	}

	return DND.DROP_NONE;
}
 

@Override
public IStatus handlePluginTransferDrop(final IStructuredSelection aDragSelection, final Object aDropTarget) {

	final IContainer target = getActualTarget(ResourceManager.getResource(aDropTarget));
	final IResource[] resources = getSelectedResources(aDragSelection);

	final MoveFilesAndFoldersOperation operation = new MoveFilesAndFoldersOperation(getShell());
	operation.copyResources(resources, target);

	if (target != null && target.isAccessible()) {
		try {
			target.refreshLocal(IResource.DEPTH_ONE, null);
		} catch (final CoreException e) {}
	}
	return Status.OK_STATUS;
}
 

private List<IResource> handleContainer(IContainer container) {
  List<IResource> children = new ArrayList<>();
  if (container.isAccessible()) {
    try {
      IResource[] members = container.members();
      for (int i = 0; i < members.length; i++) {
        if (members[i].getType() != IResource.FILE) {
          children.add(members[i]);
        }
      }
    } catch (CoreException e) {
      // this should never happen because we call
      // #isAccessible before invoking #members
    }
  }
  return children;
}
 

/**
 * @see ITreeContentProvider#getChildren
 */
public Object[] getChildren(Object element) {
	if (element instanceof IWorkspace) {
		// check if closed projects should be shown
		IProject[] allProjects = ((IWorkspace) element).getRoot().getProjects();
		if (showClosedProjects)
			return allProjects;
		
		ArrayList accessibleProjects = new ArrayList();
		for (int i = 0; i < allProjects.length; i++){
			if (allProjects[i].isOpen()){
				accessibleProjects.add(allProjects[i]);
			}
		}
		return accessibleProjects.toArray();
	} else if (element instanceof IContainer) {
		IContainer container = (IContainer)element;
		if (container.isAccessible()) {
		    try {
			    List children = new ArrayList();
			    IResource[] members = container.members();
			    for (int i = 0; i < members.length; i++) {
				    if (members[i].getType() != IResource.FILE) {
					    children.add(members[i]);
				    }
			    }
			    return children.toArray();
			} catch (CoreException e) {
				// this should never happen because we call #isAccessible before invoking #members
			}
		}
	}
	return new Object[0];
}
 

@Override
public Object[] getChildren(Object element) {

    if (element instanceof IContainer) {
        IContainer container = (IContainer) element;

        if (container.isAccessible()) {
            try {
                List<IResource> children = new ArrayList<IResource>();

                IResource[] members = container.members();

                for (int i = 0; i < members.length; i++) {

                    if (members[i] instanceof IFile) {

                        IFile file = (IFile) members[i];

                        if (PythonPathHelper.isValidSourceFile(file)) {
                            children.add(file);
                        }
                    } else if (members[i] instanceof IContainer) {
                        children.add(members[i]);
                    }
                }
                return children.toArray();
            } catch (CoreException e) {
                // this should never happen because we call #isAccessible before invoking #members
            }
        }
    }

    return new Object[0];
}
 

@Override
public Object[] getChildren(Object element) {
    if (element instanceof IWorkspace) {
        // check if closed projects should be shown
        IProject[] allProjects = ((IWorkspace) element).getRoot().getProjects();
        if (showClosedProjects)
            return allProjects;

        ArrayList<IProject> accessibleProjects = new ArrayList<IProject>();
        for (int i = 0; i < allProjects.length; i++) {
            if (allProjects[i].isOpen()) {
                accessibleProjects.add(allProjects[i]);
            }
        }
        return accessibleProjects.toArray();
    } else if (element instanceof IContainer) {
        IContainer container = (IContainer) element;
        if (container.isAccessible()) {
            try {
                List<IResource> children = new ArrayList<IResource>();
                IResource[] members = container.members();
                for (int i = 0; i < members.length; i++) {
                    if (members[i].getType() != IResource.FILE) {
                        children.add(members[i]);
                    }
                }
                return children.toArray();
            } catch (CoreException e) {
                // this should never happen because we call #isAccessible before invoking #members
            }
        }
    }
    return new Object[0];
}
 

private Map<String, ArrayList<IResource>> buildJavaToClassMap(IContainer container, IProgressMonitor monitor) throws CoreException {
	if (container == null || !container.isAccessible())
		return new HashMap<String, ArrayList<IResource>>(0);
	/*
	 * XXX: Bug 6584: Need a way to get class files for a java file (or CU)
	 */
	IClassFileReader cfReader= null;
	IResource[] members= container.members();
	Map<String, ArrayList<IResource>> map= new HashMap<String, ArrayList<IResource>>(members.length);
	for (int i= 0;  i < members.length; i++) {
		if (isClassFile(members[i])) {
			IFile classFile= (IFile)members[i];
			URI location= classFile.getLocationURI();
			if (location != null) {
				InputStream contents= null;
				try {
					contents= EFS.getStore(location).openInputStream(EFS.NONE, monitor);
					cfReader= ToolFactory.createDefaultClassFileReader(contents, IClassFileReader.CLASSFILE_ATTRIBUTES);
				} finally {
					try {
						if (contents != null)
							contents.close();
					} catch (IOException e) {
						throw new CoreException(new Status(IStatus.ERROR, JavaPlugin.getPluginId(), IStatus.ERROR,
							Messages.format(JarPackagerMessages.JarFileExportOperation_errorCannotCloseConnection, BasicElementLabels.getURLPart(Resources.getLocationString(classFile))),
							e));
					}
				}
				if (cfReader != null) {
					ISourceAttribute sourceAttribute= cfReader.getSourceFileAttribute();
					if (sourceAttribute == null) {
						/*
						 * Can't fully build the map because one or more
						 * class file does not contain the name of its
						 * source file.
						 */
						addWarning(Messages.format(
							JarPackagerMessages.JarFileExportOperation_classFileWithoutSourceFileAttribute,
							BasicElementLabels.getURLPart(Resources.getLocationString(classFile))), null);
						return null;
					}
					String javaName= new String(sourceAttribute.getSourceFileName());
					ArrayList<IResource> classFiles= map.get(javaName);
					if (classFiles == null) {
						classFiles= new ArrayList<IResource>(3);
						map.put(javaName, classFiles);
					}
					classFiles.add(classFile);
				}
			}
		}
	}
	return map;
}
 

public IStatus handleDrop(CommonDropAdapter aDropAdapter,
		DropTargetEvent aDropTargetEvent, Object aTarget) {

	if (Policy.DEBUG_DND) {
		System.out
				.println("ResourceDropAdapterAssistant.handleDrop (begin)"); //$NON-NLS-1$
	}

	// alwaysOverwrite = false;
	if (aTarget == null || aDropTargetEvent.data == null) {
		return Status.CANCEL_STATUS;
	}
	IStatus status = null;
	IResource[] resources = null;
	TransferData currentTransfer = aDropAdapter.getCurrentTransfer();
	if (LocalSelectionTransfer.getTransfer().isSupportedType(
			currentTransfer)) {
		resources = getSelectedResources();
	} else if (ResourceTransfer.getInstance().isSupportedType(
			currentTransfer)) {
		resources = (IResource[]) aDropTargetEvent.data;
	}

	if (FileTransfer.getInstance().isSupportedType(currentTransfer)) {
		status = performFileDrop(aDropAdapter, aDropTargetEvent.data);
	} else if (resources != null && resources.length > 0) {
		if ((aDropAdapter.getCurrentOperation() == DND.DROP_COPY)
				|| (aDropAdapter.getCurrentOperation() == DND.DROP_LINK)) {
			if (Policy.DEBUG_DND) {
				System.out
						.println("ResourceDropAdapterAssistant.handleDrop executing COPY."); //$NON-NLS-1$
			}
			status = performResourceCopy(aDropAdapter, getShell(),
					resources);
		} else {
			if (Policy.DEBUG_DND) {
				System.out
						.println("ResourceDropAdapterAssistant.handleDrop executing MOVE."); //$NON-NLS-1$
			}

			status = performResourceMove(aDropAdapter, resources);
		}
	}
	openError(status);
	IContainer target = getActualTarget((IResource) aTarget);
	if (target != null && target.isAccessible()) {
		try {
			target.refreshLocal(IResource.DEPTH_ONE, null);
		} catch (CoreException e) {
		}
	}
	return status;
}
 

public IStatus handleDrop(CommonDropAdapter aDropAdapter,
		DropTargetEvent aDropTargetEvent, Object aTarget) {

	if (Policy.DEBUG_DND) {
		System.out
				.println("ResourceDropAdapterAssistant.handleDrop (begin)"); //$NON-NLS-1$
	}

	// alwaysOverwrite = false;
	if (aTarget == null || aDropTargetEvent.data == null) {
		return Status.CANCEL_STATUS;
	}
	IStatus status = null;
	IResource[] resources = null;
	TransferData currentTransfer = aDropAdapter.getCurrentTransfer();
	if (LocalSelectionTransfer.getTransfer().isSupportedType(
			currentTransfer)) {
		resources = getSelectedResources();
	} else if (ResourceTransfer.getInstance().isSupportedType(
			currentTransfer)) {
		resources = (IResource[]) aDropTargetEvent.data;
	}

	if (FileTransfer.getInstance().isSupportedType(currentTransfer)) {
		status = performFileDrop(aDropAdapter, aDropTargetEvent.data);
	} else if (resources != null && resources.length > 0) {
		if ((aDropAdapter.getCurrentOperation() == DND.DROP_COPY)
				|| (aDropAdapter.getCurrentOperation() == DND.DROP_LINK)) {
			if (Policy.DEBUG_DND) {
				System.out
						.println("ResourceDropAdapterAssistant.handleDrop executing COPY."); //$NON-NLS-1$
			}
			status = performResourceCopy(aDropAdapter, getShell(),
					resources);
		} else {
			if (Policy.DEBUG_DND) {
				System.out
						.println("ResourceDropAdapterAssistant.handleDrop executing MOVE."); //$NON-NLS-1$
			}

			status = performResourceMove(aDropAdapter, resources);
		}
	}
	openError(status);
	IContainer target = getActualTarget((IResource) aTarget);
	if (target != null && target.isAccessible()) {
		try {
			target.refreshLocal(IResource.DEPTH_ONE, null);
		} catch (CoreException e) {
		}
	}
	return status;
}
 

public void execute(IFile programFile) throws IOException, InterruptedException {
	IContainer programContainer = programFile.getParent();
	if (!programContainer.isAccessible()) {
		throw new RuntimeException(
				"Test program container " + programContainer.getLocation().toOSString() + " inaccessible");
	}

	File directory = programContainer.getLocation().toFile();
	Process process = new ProcessBuilder(programFile.getLocation().toOSString()).redirectErrorStream(true)
			.directory(directory).start();
	BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));

	boolean started = false;
	boolean running = false;
	StringBuilder message = new StringBuilder();
	String line;
	while ((line = reader.readLine()) != null) {
		if (line.startsWith("[====")) {
			if (started) {
				started = false;
				// Eat remaining input
				char[] buffer = new char[4096];
				while (reader.read(buffer) != -1);
				break;
			}
			started = true;
		} else {
			TestOutput testOutput = parseTestOutput(line);
			if (testOutput != null) {
				Description description = testOutput.toDescription();
				switch (testOutput.getStatus()) {
					case TestOutput.RUN :
						running = true;
						message.setLength(0);
						testStarted(description);
						break;
					case TestOutput.OK :
						running = false;
						testFinished(description);
						break;
					default :
						running = false;
						testFailed(description, message.toString());
						testFinished(description);
						break;
				}
			} else if (running) {
				message.append(line);
				message.append("\n");
			}
		}
	}

	process.waitFor();

	if (started) {
		throw new RuntimeException("Test quit unexpectedly (exit status " + process.exitValue() + "):\n" + message);
	}
}
 

public Object[] getChildren( Object element )
{
	if ( element instanceof IWorkspace )
	{
		// check if closed projects should be shown
		IProject[] allProjects = ( (IWorkspace) element ).getRoot( )
				.getProjects( );
		if ( showClosedProjects )
			return allProjects;

		ArrayList accessibleProjects = new ArrayList( );
		for ( int i = 0; i < allProjects.length; i++ )
		{
			if ( allProjects[i].isOpen( ) )
			{
				accessibleProjects.add( allProjects[i] );
			}
		}
		return accessibleProjects.toArray( );
	}
	else if ( element instanceof IContainer )
	{
		IContainer container = (IContainer) element;
		if ( container.isAccessible( ) )
		{
			try
			{
				List children = new ArrayList( );
				IResource[] members = container.members( );
				for ( int i = 0; i < members.length; i++ )
				{
					if ( members[i].getType( ) != IResource.FILE )
					{
						children.add( members[i] );
					}
				}
				return children.toArray( );
			}
			catch ( CoreException e )
			{
				// this should never happen because we call #isAccessible
				// before invoking #members
			}
		}
	}
	return new Object[0];
}
 

@Override
public IStatus handleDrop(CommonDropAdapter aDropAdapter, DropTargetEvent aDropTargetEvent, Object aTarget) {
    //        aTarget = getActual(aTarget);
    if (DEBUG) {
        System.out.println("ResourceDropAdapterAssistant.handleDrop (begin)"); //$NON-NLS-1$
    }

    // alwaysOverwrite = false;
    if (getCurrentTarget(aDropAdapter) == null || aDropTargetEvent.data == null) {
        return Status.CANCEL_STATUS;
    }
    IStatus status = null;
    IResource[] resources = null;
    TransferData currentTransfer = aDropAdapter.getCurrentTransfer();
    if (LocalSelectionTransfer.getTransfer().isSupportedType(currentTransfer)) {
        resources = getSelectedResources();
    } else if (ResourceTransfer.getInstance().isSupportedType(currentTransfer)) {
        resources = (IResource[]) aDropTargetEvent.data;
    }

    if (FileTransfer.getInstance().isSupportedType(currentTransfer)) {
        status = performFileDrop(aDropAdapter, aDropTargetEvent.data);
    } else if (resources != null && resources.length > 0) {
        if (aDropAdapter.getCurrentOperation() == DND.DROP_COPY) {
            if (DEBUG) {
                System.out.println("ResourceDropAdapterAssistant.handleDrop executing COPY."); //$NON-NLS-1$
            }
            status = performResourceCopy(aDropAdapter, getShell(), resources);
        } else {
            if (DEBUG) {
                System.out.println("ResourceDropAdapterAssistant.handleDrop executing MOVE."); //$NON-NLS-1$
            }

            status = performResourceMove(aDropAdapter, resources);
        }
    }
    openError(status);
    IContainer target = getActualTarget((IResource) getCurrentTarget(aDropAdapter));
    if (target != null && target.isAccessible()) {
        try {
            target.refreshLocal(IResource.DEPTH_ONE, null);
        } catch (CoreException e) {
        }
    }
    return status;
}