org.netbeans.modules.project.ui.PhysicalView Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.netbeans.modules.project.ui;
import java.awt.Image;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.SwingUtilities;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectInformation;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;
import org.netbeans.api.queries.VisibilityQuery;
import static org.netbeans.modules.project.ui.Bundle.*;
import org.netbeans.spi.project.ui.LogicalViewProvider;
import org.netbeans.spi.project.ui.support.CommonProjectActions;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileStateInvalidException;
import org.openide.filesystems.FileUIUtils;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.ChangeableDataFilter;
import org.openide.loaders.DataFilter;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.nodes.FilterNode;
import org.openide.nodes.Node;
import org.openide.nodes.NodeEvent;
import org.openide.nodes.NodeListener;
import org.openide.nodes.NodeMemberEvent;
import org.openide.nodes.NodeNotFoundException;
import org.openide.nodes.NodeOp;
import org.openide.nodes.NodeReorderEvent;
import org.openide.util.ChangeSupport;
import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.NbBundle.Messages;
import org.openide.util.RequestProcessor;
import org.openide.util.WeakListeners;
import org.openide.util.lookup.Lookups;
import org.openide.util.lookup.ProxyLookup;
/**
* Support for creating logical views.
* @author Jesse Glick, Petr Hrebejk
*/
public class PhysicalView {
private PhysicalView() {}
private static final Logger LOG = Logger.getLogger(PhysicalView.class.getName());
private static final RequestProcessor RP = new RequestProcessor(PhysicalView.class);
private static final class GroupNodeInfo {
public final boolean isProjectDir;
public GroupNodeInfo(boolean isProjectDir) {
this.isProjectDir = isProjectDir;
}
}
public static boolean isProjectDirNode( Node n ) {
GroupNodeInfo i = n.getLookup().lookup(GroupNodeInfo.class);
return i != null && i.isProjectDir;
}
public static Node[] createNodesForProject( Project p ) {
Sources s = ProjectUtils.getSources(p);
SourceGroup[] groups = s.getSourceGroups(Sources.TYPE_GENERIC);
final List nodesList = new ArrayList<>( groups.length );
for (SourceGroup group : groups) {
final Node n = createNodeForSourceGroup(group, p);
if (n != null) {
nodesList.add(n);
}
}
Node nodes[] = new Node[ nodesList.size() ];
nodesList.toArray( nodes );
return nodes;
}
@CheckForNull
static Node createNodeForSourceGroup(
@NonNull final SourceGroup group,
@NonNull final Project project) {
if ("sharedlibraries".equals(group.getName())) { //NOI18N
//HACK - ignore shared libs group in UI, it's only useful for version control commits.
return null;
}
final FileObject rootFolder = group.getRootFolder();
if (!rootFolder.isValid() || !rootFolder.isFolder()) {
return null;
}
final FileObject projectDirectory = project.getProjectDirectory();
return new ProjectIconNode(new GroupNode(
project,
group,
projectDirectory.equals(rootFolder) || FileUtil.isParentOf(rootFolder, projectDirectory),
DataFolder.findFolder(rootFolder)),
true);
}
static final class VisibilityQueryDataFilter implements ChangeListener, ChangeableDataFilter, DataFilter.FileBased {
private final ChangeSupport changeSupport = new ChangeSupport( this );
public VisibilityQueryDataFilter() {
VisibilityQuery.getDefault().addChangeListener( this );
}
public @Override boolean acceptDataObject(DataObject obj) {
return acceptFileObject(obj.getPrimaryFile());
}
public @Override void stateChanged(ChangeEvent e) {
final Runnable r = new Runnable () {
public @Override void run() {
changeSupport.fireChange();
}
};
SwingUtilities.invokeLater(r);
}
public @Override void addChangeListener(ChangeListener listener) {
changeSupport.addChangeListener( listener );
}
public @Override void removeChangeListener(ChangeListener listener) {
changeSupport.removeChangeListener( listener );
}
public @Override boolean acceptFileObject(FileObject fo) {
return VisibilityQuery.getDefault().isVisible(fo);
}
}
static final class GroupNode extends FilterNode implements PropertyChangeListener {
private static final DataFilter VISIBILITY_QUERY_FILTER = new VisibilityQueryDataFilter();
private ProjectInformation pi;
private SourceGroup group;
private boolean isProjectDir;
private Boolean initialized;
private final Node projectDelegateNode;
public GroupNode(Project project, SourceGroup group, boolean isProjectDir, DataFolder dataFolder ) {
super( dataFolder.getNodeDelegate(),
dataFolder.createNodeChildren( VISIBILITY_QUERY_FILTER ),
createLookup(project, group, dataFolder, isProjectDir));
this.pi = ProjectUtils.getInformation( project );
this.group = group;
this.isProjectDir = isProjectDir;
if(isProjectDir) {
LogicalViewProvider lvp = project.getLookup().lookup(LogicalViewProvider.class);
// used to retrieve e.g. actions in case of a folder representing a project,
// so that a projects context menu is the same is in a logical view
this.projectDelegateNode = lvp != null ? lvp.createLogicalView() : null;
} else {
this.projectDelegateNode = null;
}
pi.addPropertyChangeListener(WeakListeners.propertyChange(this, pi));
group.addPropertyChangeListener( WeakListeners.propertyChange( this, group ) );
}
private boolean initialized() {
synchronized (RP) {
if (initialized != null) {
return initialized;
} else {
initialized = false;
RP.post(new Runnable() {
@Override public void run() {
pi.getDisplayName();
synchronized (RP) {
initialized = true;
}
fireNameChange(null, null);
fireDisplayNameChange(null, null);
}
});
return false;
}
}
}
// XXX May need to change icons as well
public @Override String getName() {
if (isProjectDir && initialized()) {
return pi.getName();
}
else {
String n = group.getName();
if (n == null) {
n = "???"; // NOI18N
LOG.log(Level.WARNING, "SourceGroup impl of type {0} specified a null getName(); this is illegal", group.getClass().getName());
}
return n;
}
}
@Messages({"# {0} - display name of the group", "# {1} - display name of the project", "# {2} - original name of the folder", "FMT_PhysicalView_GroupName={1} - {0}"})
public @Override String getDisplayName() {
if ( isProjectDir ) {
return initialized() ? pi.getDisplayName() : group.getDisplayName();
}
else {
return FMT_PhysicalView_GroupName(group.getDisplayName(), pi.getDisplayName(), getOriginal().getDisplayName());
}
}
@Messages({"HINT_project=Project in {0}", "HINT_group=Source folder in {0}"})
public @Override String getShortDescription() {
FileObject gdir = group.getRootFolder();
String dir = FileUtil.getFileDisplayName(gdir);
return isProjectDir ? HINT_project(dir) : HINT_group(dir);
}
public @Override boolean canRename() {
return false;
}
@Override public Node.PropertySet[] getPropertySets() {
return new Node.PropertySet[0];
}
public @Override boolean canCut() {
return false;
}
public @Override boolean canCopy() {
// At least for now.
return false;
}
public @Override boolean canDestroy() {
return false;
}
public @Override Action[] getActions(boolean context) {
if ( context ) {
return super.getActions( true );
}
else {
Action[] folderActions = super.getActions( false );
Action[] projectActions;
if ( isProjectDir ) {
if( projectDelegateNode != null ) {
projectActions = projectDelegateNode.getActions( false );
}
else {
// If this is project dir then the properties action
// has to be replaced to invoke project customizer
projectActions = new Action[ folderActions.length ];
for ( int i = 0; i < folderActions.length; i++ ) {
if ( folderActions[i] instanceof org.openide.actions.PropertiesAction ) {
projectActions[i] = CommonProjectActions.customizeProjectAction();
}
else {
projectActions[i] = folderActions[i];
}
}
}
}
else {
projectActions = folderActions;
}
return projectActions;
}
}
// Private methods -------------------------------------------------
public @Override void propertyChange(final PropertyChangeEvent evt) {
final Runnable r = new Runnable () {
public @Override void run() {
String prop = evt.getPropertyName();
boolean ok = false;
if (prop == null || ProjectInformation.PROP_DISPLAY_NAME.equals(prop)) {
fireDisplayNameChange(null, null);
ok = true;
}
if (prop == null || ProjectInformation.PROP_NAME.equals(prop)) {
fireNameChange(null, null);
ok = true;
}
if (prop == null || ProjectInformation.PROP_ICON.equals(prop)) {
// OK, ignore
ok = true;
}
if (prop == null || "name".equals(prop) ) { // NOI18N
fireNameChange(null, null);
ok = true;
}
if (prop == null || "displayName".equals(prop) ) { // NOI18N
fireDisplayNameChange(null, null);
ok = true;
}
if (prop == null || "icon".equals(prop) ) { // NOI18N
// OK, ignore
ok = true;
}
if (prop == null || "rootFolder".equals(prop) ) { // NOI18N
// XXX Do something to children and lookup
fireNameChange(null, null);
fireDisplayNameChange(null, null);
fireShortDescriptionChange(null, null);
ok = true;
}
if (prop == null || SourceGroup.PROP_CONTAINERSHIP.equals(prop)) {
// OK, ignore
ok = true;
}
if (!ok) {
assert false : "Attempt to fire an unsupported property change event from " + pi.getClass().getName() + ": " + prop;
}
}
};
SwingUtilities.invokeLater(r);
}
private static Lookup createLookup(Project p, SourceGroup group, DataFolder dataFolder, boolean isProjectDir) {
return new ProxyLookup(
dataFolder.getNodeDelegate().getLookup(),
Lookups.fixed(p, new PathFinder(group), new GroupNodeInfo(isProjectDir)),
p.getLookup());
}
}
static final class ProjectIconNode extends FilterNode implements NodeListener { // #194068
private final boolean root;
public ProjectIconNode(Node orig, boolean root) {
super(orig, orig.isLeaf() ? Children.LEAF : new ProjectBadgingChildren(orig));
this.root = root;
setValue("VCS_PHYSICAL", Boolean.TRUE); //#159543
addNodeListener(this);
}
@Override
protected NodeListener createNodeListener() {
return new NodeAdapter(this) {
@Override
protected void propertyChange(FilterNode fn, PropertyChangeEvent ev) {
super.propertyChange(fn, ev);
if (Node.PROP_LEAF.equals(ev.getPropertyName())) {
Node orig = getOriginal();
setChildren(orig.isLeaf() ? Children.LEAF : new ProjectBadgingChildren(orig));
}
}
};
}
public @Override Image getIcon(int type) {
return swap(super.getIcon(type), type);
}
public @Override Image getOpenedIcon(int type) {
return swap(super.getOpenedIcon(type), type);
}
private Image swap(Image base, int type) {
if (!root) { // do not use icon on root node in Files tab
FileObject folder = getOriginal().getLookup().lookup(FileObject.class);
if (folder != null && folder.isFolder()) {
ProjectManager.Result r = ProjectManager.getDefault().isProject2(folder);
if (r != null) {
Icon icon = r.getIcon();
if (icon != null) {
Image img = ImageUtilities.icon2Image(icon);
try {
//#217008
DataFolder df = getOriginal().getLookup().lookup(DataFolder.class);
img = FileUIUtils.getImageDecorator(folder.getFileSystem()).annotateIcon(img, type, df.files());
} catch (FileStateInvalidException e) {
// no fs, do nothing
}
return img;
}
}
}
}
return base;
}
public @Override String getShortDescription() {
FileObject folder = getOriginal().getLookup().lookup(FileObject.class);
if (folder != null && folder.isFolder()) {
try {
Project p = ProjectManager.getDefault().findProject(folder);
if (p != null) {
return ProjectUtils.getInformation(p).getDisplayName();
}
} catch (IOException x) {
LOG.log(Level.FINE, null, x);
}
}
return super.getShortDescription();
}
@Override
public void childrenAdded(NodeMemberEvent ev) {
}
@Override
public void childrenRemoved(NodeMemberEvent ev) {
}
@Override
public void childrenReordered(NodeReorderEvent ev) {
}
@Override
public void nodeDestroyed(NodeEvent ev) {
}
@Override
public void propertyChange(PropertyChangeEvent evt) {
}
}
private static final class ProjectBadgingChildren extends FilterNode.Children {
public ProjectBadgingChildren(Node orig) {
super(orig);
}
protected @Override Node copyNode(Node orig) {
return new ProjectIconNode(orig, false);
}
}
public static class PathFinder {
private SourceGroup group;
public PathFinder( SourceGroup group ) {
this.group = group;
}
public Node findPath( Node root, Object object ) {
if ( !( object instanceof FileObject ) ) {
return null;
}
FileObject fo = (FileObject)object;
FileObject groupRoot = group.getRootFolder();
if ( FileUtil.isParentOf( groupRoot, fo ) /* && group.contains( fo ) */ ) {
// The group contains the object
String relPath = FileUtil.getRelativePath( groupRoot, fo );
ArrayList path = new ArrayList();
StringTokenizer strtok = new StringTokenizer( relPath, "/" );
while( strtok.hasMoreTokens() ) {
path.add( strtok.nextToken() );
}
if (path.size() > 0) {
path.remove(path.size() - 1);
} else {
return null;
}
try {
//#75205
Node parent = NodeOp.findPath( root, Collections.enumeration( path ) );
if (parent != null) {
//not nice but there isn't a findNodes(name) method.
Node[] nds = parent.getChildren().getNodes(true);
for (int i = 0; i < nds.length; i++) {
FileObject dobj = nds[i].getLookup().lookup(FileObject.class);
if (dobj != null && fo.equals(dobj)) {
return nds[i];
}
}
String name = fo.getName();
try {
DataObject dobj = DataObject.find( fo );
name = dobj.getNodeDelegate().getName();
} catch (DataObjectNotFoundException ex) {
}
return parent.getChildren().findChild(name);
}
}
catch ( NodeNotFoundException e ) {
return null;
}
}
else if ( groupRoot.equals( fo ) ) {
return root;
}
return null;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy