| /******************************************************************************* |
| * Copyright (c) 2002, 2015 IBM Corporation and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM - Initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.core.tools.resources; |
| |
| import java.util.*; |
| import org.eclipse.core.internal.events.BuildManager; |
| import org.eclipse.core.internal.events.BuilderPersistentInfo; |
| import org.eclipse.core.internal.resources.Workspace; |
| import org.eclipse.core.internal.watson.ElementTree; |
| import org.eclipse.core.resources.*; |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.core.tools.AbstractTreeContentProvider; |
| import org.eclipse.core.tools.TreeContentProviderNode; |
| import org.eclipse.jface.util.SafeRunnable; |
| import org.eclipse.jface.viewers.Viewer; |
| |
| /** |
| * Constructs a tree made of <code>TreeContentProviderNode</code>s, representing |
| * several details about projects. |
| * Details include: |
| * <ul> |
| * <li>project's name;</li> |
| * <li>the builders associated to this project. For each builder it shows:<ul> |
| * <li>the builder's name;</li> |
| * <li>the arguments;</li> |
| * <li>persistent info (interesting projects & last built tree);</li> |
| * </ul></li> |
| |
| * <li>the natures associated to this project. For each nature it shows:<ul> |
| * <li>the nature's label & Id;</li> |
| * <li>the nature sets it belongs to;</li> |
| * <li>the required natures;</li> |
| * </ul></li> |
| * </ul> |
| * |
| * |
| * @see org.eclipse.core.tools.TreeContentProviderNode |
| */ |
| public class ProjectContentProvider extends AbstractTreeContentProvider { |
| |
| /** |
| * Collects project info. Calls all other <code>extract...</code> methods. |
| * |
| * @param project the project object from where to extract information |
| */ |
| protected void extractInfo(IProject project) { |
| try { |
| IProjectDescription description = project.getDescription(); |
| extractBasicInfo(project); |
| extractBuildersInfo(project, description); |
| extractNaturesInfo(description); |
| } catch (CoreException ce) { |
| getRootNode().addChild(createNode("Error accessing project details", ce)); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Extracts basic project information. |
| * |
| * @param project the project from where to extract information |
| */ |
| |
| protected void extractBasicInfo(IProject project) { |
| getRootNode().addChild(createNode("Project name", project.getName())); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Extracts builders information from the project info object, building a 'Builders' |
| * subtree in the project information tree. |
| * |
| * @param project the project from where to extract information |
| * @param description the description from where to extract information |
| */ |
| |
| protected void extractBuildersInfo(IProject project, IProjectDescription description) { |
| ICommand[] commands = description.getBuildSpec(); |
| if (commands.length == 0) |
| return; |
| |
| // tries to retrieve builder persistent info for all builders in this |
| // project's builder spec |
| Workspace workspace = (Workspace) ResourcesPlugin.getWorkspace(); |
| BuildManager manager = workspace.getBuildManager(); |
| ArrayList<BuilderPersistentInfo> allPersistInfo = null; |
| try { |
| allPersistInfo = manager.getBuildersPersistentInfo(project); |
| } catch (CoreException ce) { |
| getRootNode().addChild(createNode("Error extracting builders info: " + ce, null)); //$NON-NLS-1$ |
| return; |
| } |
| |
| // extracts information for each builder |
| TreeContentProviderNode buildersRoot = createNode("Builders"); //$NON-NLS-1$ |
| getRootNode().addChild(buildersRoot); |
| for (int i = 0; i < commands.length; i++) { |
| String builderName = commands[i].getBuilderName(); |
| TreeContentProviderNode builderNode = createNode("Builder name", builderName); //$NON-NLS-1$ |
| buildersRoot.addChild(builderNode); |
| |
| // extracts information about arguments |
| extractBuilderArguments(builderNode, commands[i].getArguments()); |
| |
| // extracts information from persistent info (if available) |
| if (allPersistInfo != null) { |
| //find persistent info for this builder |
| for (BuilderPersistentInfo info : allPersistInfo) { |
| if (info.getBuilderName().equals(builderName)) { |
| extractBuilderPersistentInfo(builderNode, info); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Extracts information related to builder arguments for a given builder. |
| * |
| * @param builderNode the node where to add builder arguments nodes |
| * @param builderArgs a map containing arguments for a builder |
| */ |
| protected void extractBuilderArguments(TreeContentProviderNode builderNode, Map<String, String> builderArgs) { |
| if (builderArgs == null || builderArgs.isEmpty()) |
| return; |
| |
| TreeContentProviderNode builderArgsRoot = createNode("Builder args"); //$NON-NLS-1$ |
| builderNode.addChild(builderArgsRoot); |
| for (Map.Entry<String, String> entry : builderArgs.entrySet()) { |
| TreeContentProviderNode builderArgNode = createNode(entry.getKey(), entry.getValue()); |
| builderArgsRoot.addChild(builderArgNode); |
| } |
| } |
| |
| /** |
| * Extracts builder persistent info, if any. |
| * |
| * @param builderNode the node where to add persistent info nodes |
| * @param persistInfo the persistent info |
| */ |
| protected void extractBuilderPersistentInfo(TreeContentProviderNode builderNode, BuilderPersistentInfo persistInfo) { |
| |
| if (persistInfo == null) |
| return; |
| |
| // extracts information about interesting projects |
| IProject[] interestingProjects = persistInfo.getInterestingProjects(); |
| if (interestingProjects.length > 0) { |
| TreeContentProviderNode interestingRoot = createNode("Interesting projects"); //$NON-NLS-1$ |
| for (int j = 0; j < interestingProjects.length; j++) |
| interestingRoot.addChild(createNode(interestingProjects[j].getName())); |
| builderNode.addChild(interestingRoot); |
| } |
| |
| // extracts information about last built tree (just a String rep for now) |
| ElementTree lastBuiltTree = persistInfo.getLastBuiltTree(); |
| builderNode.addChild(createNode("Last built tree", lastBuiltTree.toString())); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Extracts from project description object all information regarding natures, |
| * building a 'Natures' subtree in the projects information tree. |
| * |
| * @param description a project description |
| */ |
| protected void extractNaturesInfo(IProjectDescription description) { |
| String[] natureIds = description.getNatureIds(); |
| if (natureIds.length == 0) |
| return; |
| |
| // extracts information about each nature assigned to the project |
| TreeContentProviderNode naturesRoot = createNode("Natures"); //$NON-NLS-1$ |
| getRootNode().addChild(naturesRoot); |
| Workspace workspace = (Workspace) ResourcesPlugin.getWorkspace(); |
| for (int i = 0; i < natureIds.length; i++) { |
| IProjectNatureDescriptor descriptor = workspace.getNatureDescriptor(natureIds[i]); |
| String nodeName = (descriptor == null ? "Missing" : descriptor.getLabel()) + " (" + natureIds[i] + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| TreeContentProviderNode natureNode = createNode(nodeName); |
| naturesRoot.addChild(natureNode); |
| |
| // we may not have the descriptor for this nature if (for instance) the |
| // project was created in a different workspace with a plug-in that we don't have |
| if (descriptor != null) { |
| // lists nature sets to which the current nature belongs |
| String[] natureSets = descriptor.getNatureSetIds(); |
| if (natureSets.length > 0) { |
| TreeContentProviderNode setsNode = createNode("Nature sets"); //$NON-NLS-1$ |
| for (int j = 0; j < natureSets.length; j++) |
| setsNode.addChild(createNode(natureSets[i])); |
| natureNode.addChild(setsNode); |
| } |
| |
| // lists nature sets which the current nature requires |
| String[] requiredNatures = descriptor.getRequiredNatureIds(); |
| if (requiredNatures.length > 0) { |
| TreeContentProviderNode requiredNaturesNode = createNode("Required natures", null); //$NON-NLS-1$ |
| for (int j = 0; j < requiredNatures.length; j++) |
| requiredNaturesNode.addChild(createNode(requiredNatures[j], null)); |
| natureNode.addChild(requiredNaturesNode); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Reconstructs this content provider data model upon the provided input object. |
| * |
| * @param input the new input object - must not be null |
| */ |
| @Override |
| protected void rebuild(Viewer viewer, final Object input) { |
| SafeRunner.run(new SafeRunnable() { |
| @Override |
| public void run() throws Exception { |
| extractInfo(((IResource) input).getProject()); |
| } |
| }); |
| } |
| |
| /** |
| * Returns true if the input is a resource. |
| * |
| * @param input an input object |
| * @return true if the provided input is a resource |
| * @see org.eclipse.core.tools.AbstractTreeContentProvider#acceptInput(java.lang.Object) |
| */ |
| @Override |
| protected boolean acceptInput(Object input) { |
| return input instanceof IResource; |
| } |
| |
| } |
