org.openide.filesystems.FileSystemCompat 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.openide.filesystems;
import java.awt.Image;
import java.awt.Toolkit;
import java.beans.BeanInfo;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.Set;
import static org.openide.filesystems.FileSystem.LOG;
import org.openide.modules.PatchFor;
import org.openide.util.Exceptions;
import org.openide.util.ImageUtilities;
import org.openide.util.actions.SystemAction;
/**
* The class provides an API compatibility bridge to support implementations
* compiled against org.openide.filesystems<8.0 and earlier
*
* @author sdedic
*/
@PatchFor(FileSystem.class)
public abstract class FileSystemCompat {
/** system actions for this FS */
private static final SystemAction[] NO_SYSTEM_ACTIONS = new SystemAction[0];
/** Property name giving capabilities state. @deprecated No more capabilities. */
static final String PROP_CAPABILITIES = "capabilities"; // NOI18N
/** hidden flag */
private boolean hidden = false;
/** Describes capabilities of the filesystem.
*/
@Deprecated // have to store it for compat
private /* XXX JDK #6460147: javac still reports it even though @Deprecated,
and @SuppressWarnings("deprecation") does not help either: FileSystemCapability*/Object capability;
/** property listener on FileSystemCapability. */
private transient PropertyChangeListener capabilityListener;
/** Returns an array of actions that can be invoked on any file in
* this filesystem.
* These actions should preferably
* support the {@link org.openide.util.actions.Presenter.Menu Menu},
* {@link org.openide.util.actions.Presenter.Popup Popup},
* and {@link org.openide.util.actions.Presenter.Toolbar Toolbar} presenters.
*
* @return array of available actions
*/
@SuppressWarnings("ReturnOfCollectionOrArrayField")
public SystemAction[] getActions() {
// If implementations don't override getActions, an empty array is
// returned to satisfy the FileSystem#getActions contract. As the
// empty array is immutable, it is save to return a singleton in this
// case
return NO_SYSTEM_ACTIONS;
}
/**
* Get actions appropriate to a certain file selection.
* By default, returns the same list as {@link #getActions()}.
* @param foSet one or more files which may be selected
* @return zero or more actions appropriate to those files
*/
public SystemAction[] getActions(Set foSet) {
return this.getActions();
}
/** Allows filesystems to set up the environment for external execution
* and compilation.
* Each filesystem can add its own values that
* influence the environment. The set of operations that can modify
* environment is described by the {@link Environment} interface.
*
* The default implementation throws an exception to signal that it does not
* support external compilation or execution.
*
* @param env the environment to setup
* @exception EnvironmentNotSupportedException if external execution
* and compilation cannot be supported
* @deprecated Please use the ClassPath API instead.
*/
@Deprecated
public void prepareEnvironment(FileSystem$Environment env) throws EnvironmentNotSupportedException {
Object o = this;
throw new EnvironmentNotSupportedException((FileSystem)o);
}
/**
* Provides access to deprecated methods at runtime.
*
* @param fs The FileSystem
* @return the FileSystemCompat instanceo for the FileSystem.
*/
public static FileSystemCompat compat(FileSystem fs) {
Object o = fs;
return (FileSystemCompat)o;
}
private FileSystem fs() {
Object o = this;
return (FileSystem)o;
}
/** The object describing capabilities of this filesystem.
* Subclasses cannot override it.
* @return object describing capabilities of this filesystem.
* @deprecated Capabilities are no longer used.
*/
@Deprecated
public final FileSystemCapability getCapability() {
if (capability == null) {
capability = new FileSystemCapability.Bean();
((FileSystemCapability) capability).addPropertyChangeListener(getCapabilityChangeListener());
}
return (FileSystemCapability) capability;
}
/** Allows subclasses to change a set of capabilities of the
* filesystem.
* @param capability the capability to use
* @deprecated Capabilities are no longer used.
*/
@Deprecated
protected final void setCapability(FileSystemCapability capability) {
if (this.capability != null) {
((FileSystemCapability) this.capability).removePropertyChangeListener(getCapabilityChangeListener());
}
this.capability = capability;
if (this.capability != null) {
((FileSystemCapability) this.capability).addPropertyChangeListener(getCapabilityChangeListener());
}
}
/** returns property listener on FileSystemCapability. */
private synchronized PropertyChangeListener getCapabilityChangeListener() {
if (capabilityListener == null) {
capabilityListener = new PropertyChangeListener() {
public void propertyChange(java.beans.PropertyChangeEvent propertyChangeEvent) {
fs().firePropertyChange(
PROP_CAPABILITIES, propertyChangeEvent.getOldValue(), propertyChangeEvent.getNewValue()
);
}
};
}
return capabilityListener;
}
/** Reads object from stream and creates listeners.
* @param in the input stream to read from
* @exception IOException error during read
* @exception ClassNotFoundException when class not found
*/
@SuppressWarnings("deprecation")
private void readObject(java.io.ObjectInputStream in)
throws java.io.IOException, java.lang.ClassNotFoundException {
in.defaultReadObject();
if (capability != null) {
((FileSystemCapability) capability).addPropertyChangeListener(getCapabilityChangeListener());
}
}
/** Set hidden state of the object.
* A hidden filesystem is not presented to the user in the Repository list (though it may be present in the Repository Settings list).
*
* @param hide true if the filesystem should be hidden
* @deprecated This property is now useless.
*/
@Deprecated
public final void setHidden(boolean hide) {
if (hide != hidden) {
hidden = hide;
fs().firePropertyChange(FileSystem.PROP_HIDDEN, (!hide) ? Boolean.TRUE : Boolean.FALSE, hide ? Boolean.TRUE : Boolean.FALSE);
}
}
/** Getter for the hidden property.
* @return the hidden property.
* @deprecated This property is now useless.
*/
@Deprecated
public final boolean isHidden() {
return hidden;
}
/** Tests whether filesystem will survive reloading of system pool.
* If true then when
* {@link Repository} is reloading its content, it preserves this
* filesystem in the pool.
*
* This can be used when the pool contains system level and user level
* filesystems. The system ones should be preserved when the user changes
* the content (for example when he is loading a new project).
*
The default implementation returns false.
*
* @return true if the filesystem should be persistent
* @deprecated This property is long since useless.
*/
@Deprecated
protected boolean isPersistent() {
return false;
}
static {
try {
Field f = FileSystem.class.getDeclaredField("SFS_STATUS"); // NOI18N
f.setAccessible(true);
StatusDecorator del = (StatusDecorator)f.get(null);
f.set(null, new SystemStatus(del));
} catch (NoSuchFieldException ex) {
Exceptions.printStackTrace(ex);
} catch (SecurityException ex) {
Exceptions.printStackTrace(ex);
} catch (IllegalArgumentException ex) {
Exceptions.printStackTrace(ex);
} catch (IllegalAccessException ex) {
Exceptions.printStackTrace(ex);
}
}
/**
* Enhancement of the default SFS_Status, loads image through ImageUtilities.
*/
private static class SystemStatus implements FileSystem$Status, StatusDecorator {
private final StatusDecorator delegate;
public SystemStatus(StatusDecorator delegate) {
this.delegate = delegate;
}
@Override
public String annotateName(String name, Set files) {
return delegate.annotateName(name, files);
}
@Override
public Image annotateIcon(Image im, int type, Set files) {
for (FileObject fo : files) {
Image img = annotateIcon(fo, type);
if (img != null) {
return img;
}
}
return im;
}
private Image annotateIcon(FileObject fo, int type) {
String attr = null;
if (type == BeanInfo.ICON_COLOR_16x16) {
attr = "SystemFileSystem.icon"; // NOI18N
} else if (type == BeanInfo.ICON_COLOR_32x32) {
attr = "SystemFileSystem.icon32"; // NOI18N
}
if (attr != null) {
Object value = fo.getAttribute(attr);
if (value != null) {
if (value instanceof URL) {
return Toolkit.getDefaultToolkit().getImage((URL) value);
} else if (value instanceof Image) {
// #18832
return (Image) value;
} else {
LOG.warning("Attribute " + attr + " on " + fo + " expected to be a URL or Image; was: " + value);
}
}
}
String base = (String) fo.getAttribute("iconBase"); // NOI18N
if (base != null) {
if (type == BeanInfo.ICON_COLOR_16x16) {
return ImageUtilities.loadImage(base, true);
} else if (type == BeanInfo.ICON_COLOR_32x32) {
return ImageUtilities.loadImage(insertBeforeSuffix(base, "_32"), true); // NOI18N
}
}
return null;
}
private static String insertBeforeSuffix(String path, String toInsert) {
String withoutSuffix = path;
String suffix = ""; // NOI18N
if (path.lastIndexOf('.') >= 0) {
withoutSuffix = path.substring(0, path.lastIndexOf('.'));
suffix = path.substring(path.lastIndexOf('.'), path.length());
}
return withoutSuffix + toInsert + suffix;
}
@Override
public String annotateNameHtml(String name, Set files) {
return name;
}
}
private FileSystem$Status status;
/**
* Compatible implementation of FileSystem.getStatus()
*
* @return
*/
public FileSystem$Status getStatus() {
if (status == null) {
status = new StatusImpl(fs().getDecorator());
}
return status;
}
/**
* This is a compatible implementation of FileSystem.Status, which bridges
* a new FS implementation (Decorator, IconDecorator) to the old Status interface
*/
private static class StatusImpl implements FileSystem$Status, FileSystem$HtmlStatus {
private final StatusDecorator decorator;
private final Method annotateIconDel;
public StatusImpl(StatusDecorator decorator) {
this.decorator = decorator;
Method m = null;
try {
m = decorator.getClass().getMethod("annotateIcon", Image.class, Integer.TYPE, Set.class);
m.setAccessible(true);
} catch (NoSuchMethodException ex) {
} catch (SecurityException ex) {
Exceptions.printStackTrace(ex);
}
this.annotateIconDel = m;
}
@Override
public String annotateName(String name, Set files) {
return decorator.annotateName(name, files);
}
@Override
public Image annotateIcon(Image icon, int iconType, Set files) {
if (annotateIconDel == null) {
return icon;
}
try {
return (Image)annotateIconDel.invoke(decorator, icon, iconType, files);
} catch (IllegalAccessException ex) {
Exceptions.printStackTrace(ex);
} catch (IllegalArgumentException ex) {
Exceptions.printStackTrace(ex);
} catch (InvocationTargetException ex) {
Exceptions.printStackTrace(ex);
}
return icon;
}
@Override
public String annotateNameHtml(String name, Set files) {
return decorator.annotateNameHtml(name, files);
}
}
}