* Note: this class is only public because the so-called "fix" * for javadoc bug * 4780441 * still fails to correctly document public methods inherited from a package * private class. */ public class AbstractBean { private final PropertyChangeSupport pcs; public AbstractBean() { pcs = new SwingPropertyChangeSupport(this, true); } /** * Add a PropertyChangeListener to the listener list. * The listener is registered for all properties and its * {@code propertyChange} method will run on the event dispatching * thread. *
* If {@code listener} is null, no exception is thrown and no action * is taken. * * @param listener the PropertyChangeListener to be added. * @see #removePropertyChangeListener * @see java.beans.PropertyChangeSupport#addPropertyChangeListener */ public void addPropertyChangeListener(PropertyChangeListener listener) { pcs.addPropertyChangeListener(listener); } /** * Remove a PropertyChangeListener from the listener list. *
* If {@code listener} is null, no exception is thrown and no action
* is taken.
*
* @param listener the PropertyChangeListener to be removed.
* @see #addPropertyChangeListener
* @see java.beans.PropertyChangeSupport#removePropertyChangeListener
*/
public void removePropertyChangeListener(PropertyChangeListener listener) {
pcs.removePropertyChangeListener(listener);
}
/**
* Add a PropertyChangeListener for a specific property. The listener
* will be invoked only when a call on firePropertyChange names that
* specific property.
* The same listener object may be added more than once. For each
* property, the listener will be invoked the number of times it was added
* for that property.
* If propertyName or listener is null, no
* exception is thrown and no action is taken.
*
* @param propertyName The name of the property to listen on.
* @param listener the PropertyChangeListener to be added
* @see java.beans.PropertyChangeSupport#addPropertyChangeListener(String, PropertyChangeListener)
*/
public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
pcs.addPropertyChangeListener(propertyName, listener);
}
/**
* Remove a PropertyChangeListener for a specific property.
* If listener was added more than once to the same event
* source for the specified property, it will be notified one less time
* after being removed.
* If propertyName is null, no exception is thrown and no
* action is taken.
* If listener is null, or was never added for the specified
* property, no exception is thrown and no action is taken.
*
* @param propertyName The name of the property that was listened on.
* @param listener The PropertyChangeListener to be removed
* @see java.beans.PropertyChangeSupport#removePropertyChangeListener(String, PropertyChangeListener)
*/
public synchronized void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
pcs.removePropertyChangeListener(propertyName, listener);
}
/**
* An array of all of the {@code PropertyChangeListeners} added so far.
*
* @return all of the {@code PropertyChangeListeners} added so far.
* @see java.beans.PropertyChangeSupport#getPropertyChangeListeners
*/
public PropertyChangeListener[] getPropertyChangeListeners() {
return pcs.getPropertyChangeListeners();
}
/**
* Called whenever the value of a bound property is set.
*
* If oldValue is not equal to newValue, invoke the {@code * propertyChange} method on all of the {@code * PropertyChangeListeners} added so far, on the event * dispatching thread. * * @see #addPropertyChangeListener * @see #removePropertyChangeListener * @see java.beans.PropertyChangeSupport#firePropertyChange(String, Object, Object) */ protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) { if (oldValue != null && newValue != null && oldValue.equals(newValue)) { return; } pcs.firePropertyChange(propertyName, oldValue, newValue); } /** * Fire an existing PropertyChangeEvent *
* If the event's oldValue property is not equal to newValue,
* invoke the {@code propertyChange} method on all of the {@code
* PropertyChangeListeners} added so far, on the event
* dispatching thread.
*
* @see #addPropertyChangeListener
* @see #removePropertyChangeListener
* @see java.beans.PropertyChangeSupport#firePropertyChange(PropertyChangeEvent e)
*/
protected void firePropertyChange(PropertyChangeEvent e) {
pcs.firePropertyChange(e);
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/Action.java 0000664 0000000 0000000 00000006120 11516403062 0023724 0 ustar 00root root 0000000 0000000
/*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.application;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.jdesktop.application.Task.BlockingScope;
/**
* Marks a method that will be used to define a Swing
* Action object's actionPerformed
* method. It also identifies the resources that
* will be used to initialize the Action's properties.
* Additional @Action parameters can be used
* to specify the name of the bound properties (from the
* same class) that indicate if the Action is to be
* enabled/selected, and if the GUI should be blocked
* while the Action's background {@link Task} is running.
*
*
* The {@link ApplicationActionMap} class creates an
* ActionMap that contains one {@link ApplicationAction}
* for each @Action found in a target or "actions" class.
* Typically applications will use {@link
* ApplicationContext#getActionMap(Class, Object) getActionMap} to
* lazily construct and cache ApplicationActionMaps, rather than
* constructing them directly. By default the ApplicationActionMap's
* {@link ApplicationActionMap#get key} for an @Action is the
* name of the method. The name parameter can be used to
* specify a different key.
*
*
* The ApplicationAction's properties are initialized with
* resources loaded from a ResourceBundle with the same name as the
* actions class. The list of properties initialized this way
* is documented by the {@link ApplicationAction ApplicationAction's}
* constructor.
*
*
* The method marked with @Action, can have no parameters,
* or a single ActionEvent parameter. The method's return type
* can be
* Returns an {@code ActionMap} with the {@code @Actions} defined
* in the application's {@code Application} subclass, i.e. the
* the value of:
*
* The value returned by this method is cached.
*
* @return the {@code ActionMap} chain for the entire {@code Application}.
* @see #getActionMap(Class, Object)
* @see ApplicationContext#getActionMap()
* @see ApplicationContext#getActionMap(Class, Object)
* @see ApplicationContext#getActionMap(Object)
*/
public ApplicationActionMap getActionMap() {
if (globalActionMap == null) {
ApplicationContext ctx = getContext();
Object appObject = ctx.getApplication();
Class appClass = ctx.getApplicationClass();
ResourceMap resourceMap = ctx.getResourceMap();
globalActionMap = createActionMapChain(appClass, Application.class, appObject, resourceMap);
initProxyActionSupport(); // lazy initialization
}
return globalActionMap;
}
private void initProxyActionSupport() {
KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
kfm.addPropertyChangeListener(new KeyboardFocusPCL());
}
/**
* Returns the {@code ApplicationActionMap} chain for the specified
* actions class and target object.
*
* The specified class can contain methods marked with
* the {@code @Action} annotation. Each one will be turned
* into an {@link ApplicationAction ApplicationAction} object
* and all of them will be added to a single
* {@link ApplicationActionMap ApplicationActionMap}. All of the
* {@code ApplicationActions} invoke their {@code actionPerformed}
* method on the specified {@code actionsObject}.
* The parent of the returned {@code ActionMap} is the global
* {@code ActionMap} that contains the {@code @Actions} defined
* in this application's {@code Application} subclass.
*
*
* To bind an {@code @Action} to a Swing component, one specifies
* the {@code @Action's} name in an expression like this:
*
* The value returned by this method is cached. The lifetime of
* the cached entry will be the same as the lifetime of the {@code
* actionsObject} and the {@code ApplicationActionMap} and {@code
* ApplicationActions} that refer to it. In other words, if you
* drop all references to the {@code actionsObject}, including
* its {@code ApplicationActions} and their {@code
* ApplicationActionMaps}, then the cached {@code ActionMap} entry
* will be cleared.
*
* @param actionsClass
* @param actionsObject
* @see #getActionMap()
* @see ApplicationContext#getActionMap()
* @see ApplicationContext#getActionMap(Class, Object)
* @see ApplicationContext#getActionMap(Object)
* @return the {@code ApplicationActionMap} for {@code actionsClass} and {@code actionsObject}
*/
public ApplicationActionMap getActionMap(Class actionsClass, Object actionsObject) {
if (actionsClass == null) {
throw new IllegalArgumentException("null actionsClass");
}
if (actionsObject == null) {
throw new IllegalArgumentException("null actionsObject");
}
if (!actionsClass.isAssignableFrom(actionsObject.getClass())) {
throw new IllegalArgumentException("actionsObject not instanceof actionsClass");
}
synchronized (actionMaps) {
WeakReference
* This class defines a simple lifecyle for Swing applications: {@code
* initialize}, {@code startup}, {@code ready}, and {@code shutdown}.
* The {@code Application's} {@code startup} method is responsible for
* creating the initial GUI and making it visible, and the {@code
* shutdown} method for hiding the GUI and performing any other
* cleanup actions before the application exits. The {@code initialize}
* method can be used configure system properties that must be set
* before the GUI is constructed and the {@code ready}
* method is for applications that want to do a little bit of extra
* work once the GUI is "ready" to use. Concrete subclasses must
* override the {@code startup} method.
*
* Applications are started with the static {@code launch} method.
* Applications use the {@code ApplicationContext} {@link
* Application#getContext} to find resources,
* actions, local storage, and so on.
*
* All {@code Application} subclasses must override {@code startup}
* and they should call {@link #exit} (which
* calls {@code shutdown}) to exit.
* Here's an example of a complete "Hello World" Application:
*
* The {@code mainFrame's} {@code defaultCloseOperation} is set
* to {@code DO_NOTHING_ON_CLOSE} because we're handling attempts
* to close the window by calling
* {@code ApplicationContext} {@link #exit}.
*
* Simple single frame applications like the example can be defined
* more easily with the {@link SingleFrameApplication
* SingleFrameApplication} {@code Application} subclass.
*
*
* All of the Application's methods are called (must be called) on
* the EDT.
*
*
* All but the most trivial applications should define a ResourceBundle
* in the resources subpackage with the same name as the application class (like {@code
* resources/MyApplication.properties}). This ResourceBundle contains
* resources shared by the entire application and should begin with the
* following the standard Application resources:
*
* The {@code Application.lookAndFeel} resource is used to initialize the
* {@code UIManager lookAndFeel} as follows:
*
* Subclasses can provide a no-args construtor
* to initialize private final state however GUI
* initialization, and anything else that might refer to
* public API, should be done in the {@link #startup startup}
* method.
*/
protected Application() {
exitListeners = new CopyOnWriteArrayList
* This method is called by the static {@code launch} method,
* before {@code startup} is called. Subclasses that want
* to do any initialization work before {@code startup} must
* override it. The {@code initialize} method
* runs on the event dispatching thread.
*
* By default initialize() does nothing.
*
* @param args the main method's arguments.
* @see #launch
* @see #startup
* @see #shutdown
*/
protected void initialize(String[] args) {
}
/**
* Responsible for starting the application; for creating and showing
* the initial GUI.
*
* This method is called by the static {@code launch} method,
* subclasses must override it. It runs on the event dispatching
* thread.
*
* @see #launch
* @see #initialize
* @see #shutdown
*/
protected abstract void startup();
/**
* Called after the startup() method has returned and there
* are no more events on the
* {@link Toolkit#getSystemEventQueue system event queue}.
* When this method is called, the application's GUI is ready
* to use.
*
* It's usually important for an application to start up as
* quickly as possible. Applications can override this method
* to do some additional start up work, after the GUI is up
* and ready to use.
*
* @see #launch
* @see #startup
* @see #shutdown
*/
protected void ready() {
}
/**
* Called when the application {@link #exit exits}.
* Subclasses may override this method to do any cleanup
* tasks that are necessary before exiting. Obviously, you'll want to try
* and do as little as possible at this point. This method runs
* on the event dispatching thread.
*
* @see #startup
* @see #ready
* @see #exit
* @see #addExitListener
*/
protected void shutdown() {
// TBD should call TaskService#shutdownNow() on each TaskService
}
/* An event that sets a flag when it's dispatched and another
* flag, see isEventQEmpty(), that indicates if the event queue
* was empty at dispatch time.
*/
@SuppressWarnings("serial")
private static class NotifyingEvent extends PaintEvent implements ActiveEvent {
private boolean dispatched = false;
private boolean qEmpty = false;
NotifyingEvent(Component c) {
super(c, PaintEvent.UPDATE, null);
}
synchronized boolean isDispatched() {
return dispatched;
}
synchronized boolean isEventQEmpty() {
return qEmpty;
}
@Override
public void dispatch() {
EventQueue q = Toolkit.getDefaultToolkit().getSystemEventQueue();
synchronized (this) {
qEmpty = (q.peekEvent() == null);
dispatched = true;
notifyAll();
}
}
}
/* Keep queuing up NotifyingEvents until the event queue is
* empty when the NotifyingEvent is dispatched().
*/
private void waitForEmptyEventQ(JPanel placeHolder) {
boolean qEmpty = false;
EventQueue q = Toolkit.getDefaultToolkit().getSystemEventQueue();
while (!qEmpty) {
NotifyingEvent e = new NotifyingEvent(placeHolder);
q.postEvent(e);
synchronized (e) {
while (!e.isDispatched()) {
try {
e.wait();
} catch (InterruptedException ie) {
//ignore
}
}
qEmpty = e.isEventQEmpty();
}
}
}
/* When the event queue is empty, give the app a chance to do
* something, now that the GUI is "ready".
*/
private class DoWaitForEmptyEventQ extends Task
* If none of the {@code ExitListener.canExit()} methods return false,
* calls the {@code ExitListener.willExit()} methods, then
* {@code shutdown()}, and then exits the Application with
* {@link #end end}. Exceptions thrown while running willExit() or shutdown()
* are logged but otherwise ignored.
*
* If the caller is responding to an GUI event, it's helpful to pass the
* event along so that ExitListeners' canExit methods that want to popup
* a dialog know on which screen to show the dialog. For example:
*
* The {@code eventObject} argument will be the the value passed
* to {@link #exit(EventObject) exit()}. It may be null.
*
* The {@code willExit} method is called after the exit has
* been confirmed. An ExitListener that's going to perform
* some cleanup work should do so in {@code willExit}.
*
* {@code ExitListeners} run on the event dispatching thread.
*
* @see #exit(EventObject)
* @see #addExitListener
* @see #removeExitListener
*/
public interface ExitListener extends EventListener {
/**
* The method is called before the Application exits.
*
* @param event the {@code EventObject} object. It will be the the value passed
* to {@link #exit(EventObject) exit()}.
* @return {@code true} if application can proceed with shutdown process; {@code false} if
* there are pending decisions that the user must make before the app exits.
*/
boolean canExit(EventObject event);
/**
* The method is called after the exit has been confirmed.
*
* @param event the {@code EventObject} object. It will be the the value passed
* to {@link #exit(EventObject) exit()}.
*/
void willExit(EventObject event);
}
/**
* Adds an {@code ExitListener} to the list.
*
* @param listener the {@code ExitListener}
* @see #removeExitListener
* @see #getExitListeners
*/
public void addExitListener(ExitListener listener) {
exitListeners.add(listener);
}
/**
* Removes an {@code ExitListener} from the list.
*
* @param listener the {@code ExitListener}
* @see #addExitListener
* @see #getExitListeners
*/
public void removeExitListener(ExitListener listener) {
exitListeners.remove(listener);
}
/**
* All of the {@code ExitListeners} added so far.
*
* @return all of the {@code ExitListeners} added so far.
*/
public ExitListener[] getExitListeners() {
int size = exitListeners.size();
return exitListeners.toArray(new ExitListener[size]);
}
/**
* The default {@code Action} for quitting an application,
* {@code quit} just exits the application by calling {@code exit(e)}.
*
* @param e the triggering event
* @see #exit(EventObject)
*/
@Action
public void quit(ActionEvent e) {
exit(e);
}
/**
* The ApplicationContext for this Application.
*
* @return the Application's ApplicationContext
*/
public final ApplicationContext getContext() {
return context;
}
/**
* The {@code Application} singleton.
*
* This method is only called after an Application has
* been launched.
*
* @param applicationClass this Application's subclass
* @return the launched Application singleton.
* @see Application#launch
*/
public static synchronized
* This method is only called after an Application has
* been launched.
*
* @return the Application singleton or a placeholder
* @see Application#launch
* @see Application#getInstance(Class)
*/
public static synchronized Application getInstance() {
if (Beans.isDesignTime() && application==null) {
application = new DesignTimeApplication();
}
checkApplicationLaunched();
return application;
}
private static void checkApplicationLaunched() throws IllegalStateException {
if (application == null) {
throw new IllegalStateException("Application is not launched.");
}
}
/**
* Shows the application {@code View}
* @param view - View to show
* @see View
*/
public void show(View view) {
Window window = (Window) view.getRootPane().getParent();
if (window != null) {
window.pack();
window.setVisible(true);
}
}
/**
* Hides the application {@code View}
* @param view
* @see View
*/
public void hide(View view) {
view.getRootPane().getParent().setVisible(false);
}
/**
* The state of the initial UI.
* @return true if the initial UI is ready
*/
public boolean isReady() {
return ready;
}
/**
* Application placeholder class
*
* Instance of this class is created when client
* invokes static method {@code Application.getInstance()}
* @author etf
* @see Application#getInstance()
*/
private static final class DesignTimeApplication extends Application {
protected DesignTimeApplication() {
ApplicationContext ctx = getContext();
ctx.setApplicationClass(getClass());
ctx.setApplication(this);
ResourceMap appResourceMap = ctx.getResourceMap();
appResourceMap.setPlatform(PlatformType.DEFAULT);
}
@Override
protected void startup() {
}
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/ApplicationAction.java 0000664 0000000 0000000 00000101430 11516403062 0026110 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.application;
import java.awt.event.ActionEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.logging.Logger;
import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.Icon;
import javax.swing.KeyStroke;
/**
* The {@link javax.swing.Action} class used to implement the
* @Action annotation. This class is typically not
* instantiated directly, it's created as a side effect of constructing
* an ApplicationActionMap:
*
* When an ApplicationAction is constructed, it initializes all of its
* properties from the specified ResourceMap. Resource names
* must match the {@code @Action's} name, which is the name of the
* corresponding method, or the value of the optional {@code @Action} name
* parameter. To initialize the text and shortDescription properties
* of the action named "anAction" in the previous example, one
* would define two resources:
*
* A complete description of the mapping between resources and Action
* properties can be found in the ApplicationAction {@link
* #ApplicationAction constructor} documentation.
*
*
* An ApplicationAction's enabled and selected
* properties can be delegated to boolean properties of the
* Actions class, by specifying the corresponding property names.
* This can be done with the {@code @Action} annotation, e.g.:
*
* ApplicationActions can automatically block the GUI while the
* actionPerformed method is running, depending on the value of
* block annotation parameter. For example, if the value of block is
* Task.BlockingScope.ACTION, then the action will be disabled while
* the actionPerformed method runs.
*
*
* An ApplicationAction can have a proxy Action, i.e.
* another Action that provides the actionPerformed method,
* the enabled/selected properties, and values for the Action's long
* and short descriptions. If the proxy property is set, this
* ApplicationAction tracks all of the aforementioned properties, and
* the actionPerformed method just calls the proxy's
* actionPerformed method. If a proxySource is
* specified, then it becomes the source of the ActionEvent that's
* passed to the proxy actionPerformed method. Proxy action
* dispatching is as simple as this:
*
* If a {@code ResourceMap} is provided, then all of the
* {@link javax.swing.Action Action} properties are initialized
* with the values of resources whose key begins with {@code baseName}.
* ResourceMap keys are created by appending an @Action resource
* name, like "Action.shortDescription" to the @Action's baseName
* For example, Given an @Action defined like this:
*
* Then the shortDescription resource key would be
*
* The complete set of @Action resources is:
*
* A few the resources are handled specially:
*
* This name is used as a prefix to look up action resources,
* and the ApplicationContext Framework uses it as the key for this
* Action in ApplicationActionMaps.
*
*
* Note: this property should not confused with the {@link
* javax.swing.Action#NAME Action.NAME} key. That key is actually
* used to initialize the text properties of Swing
* components, which is why we call the corresponding
* ApplicationAction resource "Action.text", as in:
*
* ApplicationAction subclasses may also select values based on
* the value of the Action.Parameter annotation, which is
* passed along as the pKey argument to this method:
*
* If pType and pKey aren't recognized, this method
* calls {@link #actionFailed} with an IllegalArgumentException.
*
*
* @param pType parameter type
* @param pKey the value of the @Action.Parameter annotation
* @param actionEvent the ActionEvent that trigged this Action
*/
protected Object getActionArgument(Class pType, String pKey, ActionEvent actionEvent) {
Object argument = null;
if (pType == ActionEvent.class) {
argument = actionEvent;
} else if (pType == javax.swing.Action.class) {
argument = this;
} else if (pType == ActionMap.class) {
argument = appAM;
} else if (pType == ResourceMap.class) {
argument = resourceMap;
} else if (pType == ApplicationContext.class) {
argument = appAM.getContext();
} else if (pType == Application.class) {
argument = appAM.getContext().getApplication();
} else {
Exception e = new IllegalArgumentException("unrecognized @Action method parameter");
actionFailed(e);
}
return argument;
}
private Task.InputBlocker createInputBlocker(Task task, ActionEvent event) {
Object target = event.getSource();
if (block == Task.BlockingScope.ACTION) {
target = this;
}
return new DefaultInputBlocker(task, block, target, this);
}
private void noProxyActionPerformed(ActionEvent actionEvent) {
Object taskObject = null;
/* Create the arguments array for actionMethod by
* calling getActionArgument() for each parameter.
*/
Annotation[][] allPAnnotations = actionMethod.getParameterAnnotations();
Class[] pTypes = actionMethod.getParameterTypes();
Object[] arguments = new Object[pTypes.length];
for (int i = 0; i < pTypes.length; i++) {
String pKey = null;
for (Annotation pAnnotation : allPAnnotations[i]) {
if (pAnnotation instanceof Action.Parameter) {
pKey = ((Action.Parameter) pAnnotation).value();
break;
}
}
arguments[i] = getActionArgument(pTypes[i], pKey, actionEvent);
}
/* Call target.actionMethod(arguments). If the return value
* is a Task, then execute it.
*/
try {
Object target = appAM.getActionsObject();
taskObject = actionMethod.invoke(target, arguments);
} catch (Exception e) {
actionFailed(e);
}
if (taskObject instanceof Task) {
Task task = (Task) taskObject;
if (task.getInputBlocker() == null) {
task.setInputBlocker(createInputBlocker(task, actionEvent));
}
ApplicationContext ctx = appAM.getContext();
ctx.getTaskService().execute(task);
}
}
/**
* This method implements this Action's behavior.
*
* If there's a proxy Action then call its actionPerformed
* method. Otherwise, call the @Action method with parameter
* values provided by {@code getActionArgument()}. If anything goes wrong
* call {@code actionFailed()}.
*
* @param actionEvent @{inheritDoc}
* @see #setProxy
* @see #getActionArgument
* @see Task
*/
public void actionPerformed(ActionEvent actionEvent) {
javax.swing.Action proxy = getProxy();
if (proxy != null) {
actionEvent.setSource(getProxySource());
proxy.actionPerformed(actionEvent);
} else if (actionMethod != null) {
noProxyActionPerformed(actionEvent);
}
}
/**
* If the proxy action is null and {@code enabledProperty} was
* specified, then return the value of the enabled property's
* is/get method applied to our ApplicationActionMap's
* {@code actionsObject}.
* Otherwise return the value of this Action's enabled property.
*
* @return {@inheritDoc}
* @see #setProxy
* @see #setEnabled
* @see ApplicationActionMap#getActionsObject
*/
@Override
public boolean isEnabled() {
if ((getProxy() != null) || (isEnabledMethod == null)) {
return super.isEnabled();
} else {
try {
Object b = isEnabledMethod.invoke(appAM.getActionsObject());
return (Boolean) b;
} catch (Exception e) {
throw newInvokeError(isEnabledMethod, e);
}
}
}
/**
* If the proxy action is null and {@code enabledProperty} was
* specified, then set the value of the enabled property by
* invoking the corresponding {@code set} method on our
* ApplicationActionMap's {@code actionsObject}.
* Otherwise set the value of this Action's enabled property.
*
* @param enabled {@inheritDoc}
* @see #setProxy
* @see #isEnabled
* @see ApplicationActionMap#getActionsObject
*/
@Override
public void setEnabled(boolean enabled) {
if ((getProxy() != null) || (setEnabledMethod == null)) {
super.setEnabled(enabled);
} else {
try {
setEnabledMethod.invoke(appAM.getActionsObject(), enabled);
} catch (Exception e) {
throw newInvokeError(setEnabledMethod, e, enabled);
}
}
}
/**
* If the proxy action is null and {@code selectedProperty} was
* specified, then return the value of the selected property's
* is/get method applied to our ApplicationActionMap's {@code actionsObject}.
* Otherwise return the value of this Action's enabled property.
*
* @return true if this Action's JToggleButton is selected
* @see #setProxy
* @see #setSelected
* @see ApplicationActionMap#getActionsObject
*/
public boolean isSelected() {
if ((getProxy() != null) || (isSelectedMethod == null)) {
Object v = getValue(SELECTED_KEY);
return (v instanceof Boolean) && (Boolean) v;
} else {
return invokeBooleanMethod(appAM.getActionsObject(), isSelectedMethod);
}
}
private Boolean invokeBooleanMethod(Object obj, Method method) {
try {
Object b = method.invoke(obj);
return (Boolean) b;
} catch (Exception e) {
throw newInvokeError(method, e);
}
}
/**
* If the proxy action is null and {@code selectedProperty} was
* specified, then set the value of the selected property by
* invoking the corresponding {@code set} method on our
* ApplicationActionMap's {@code actionsObject}.
* Otherwise set the value of this Action's selected property.
*
* @param selected this Action's JToggleButton's value
* @see #setProxy
* @see #isSelected
* @see ApplicationActionMap#getActionsObject
*/
public void setSelected(boolean selected) {
if ((getProxy() != null) || (setSelectedMethod == null)) {
super.putValue(SELECTED_KEY, Boolean.valueOf(selected));
} else {
try {
super.putValue(SELECTED_KEY, Boolean.valueOf(selected));
if (selected != isSelected()) {
setSelectedMethod.invoke(appAM.getActionsObject(), selected);
}
} catch (Exception e) {
throw newInvokeError(setSelectedMethod, e, selected);
}
}
}
/**
* Keeps the {@code @Action selectedProperty} in sync when
* the value of {@code key} is {@code Action.SELECTED_KEY}.
*
* @param key {@inheritDoc}
* @param value {@inheritDoc}
*/
public void putValue(String key, Object value) {
if (SELECTED_KEY.equals(key) && (value instanceof Boolean)) {
setSelected((Boolean) value);
} else {
super.putValue(key, value);
}
}
/* Throw an Error because invoking Method m on the actionsObject,
* with the specified arguments, failed.
*/
private Error newInvokeError(Method m, Exception e, Object... args) {
StringBuilder argsString = new StringBuilder((args.length == 0) ? "" : args[0].toString());
for (int i = 1; i < args.length; i++) {
argsString.append(", ").append(args[i].toString());
}
String actionsClassName = appAM.getActionsObject().getClass().getName();
String msg = String.format("%s.%s(%s) failed", actionsClassName, m, argsString.toString());
return new Error(msg, e);
}
/* Forward the @Action class's PropertyChangeEvent e to this
* Action's PropertyChangeListeners using actionPropertyName instead
* the original @Action class's property name. This method is used
* by ApplicationActionMap#ActionsPCL to forward @Action
* enabledProperty and selectedProperty changes.
*/
void forwardPropertyChangeEvent(PropertyChangeEvent e, String actionPropertyName) {
if ("selected".equals(actionPropertyName) && (e.getNewValue() instanceof Boolean)) {
putValue(SELECTED_KEY, e.getNewValue());
}
firePropertyChange(actionPropertyName, e.getOldValue(), e.getNewValue());
}
/* Log enough output for a developer to figure out
* what went wrong.
*/
private void actionFailed(Exception e) {
// TBD Log an error
// e.printStackTrace();
throw new Error(e);
}
/**
* Returns a string representation of this
* ApplicationAction that should be useful for debugging.
* If the action is enabled it's name is enclosed by parentheses;
* if it's selected then a "+" appears after the name. If the
* action will appear with a text label, then that's included too.
* If the action has a proxy, then we append the string for
* the proxy action.
*
* @return A string representation of this ApplicationAction
*/
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getName());
sb.append(" ");
boolean enabled = isEnabled();
if (!enabled) {
sb.append("(");
}
sb.append(getName());
Object selectedValue = getValue(SELECTED_KEY);
if (selectedValue instanceof Boolean) {
if ((Boolean) selectedValue) {
sb.append("+");
}
}
if (!enabled) {
sb.append(")");
}
Object nameValue = getValue(javax.swing.Action.NAME); // [getName()].Action.text
if (nameValue instanceof String) {
sb.append(" \"");
sb.append((String) nameValue);
sb.append("\"");
}
proxy = getProxy();
if (proxy != null) {
sb.append(" Proxy for: ");
sb.append(proxy.toString());
}
return sb.toString();
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/ApplicationActionMap.java 0000664 0000000 0000000 00000023002 11516403062 0026544 0 ustar 00root root 0000000 0000000
/*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.application;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.swing.ActionMap;
/**
* An {@link javax.swing.ActionMap ActionMap} class where each entry
* corresponds to an @Action method from a single
* actionsClass (i.e. a class that contains one or more
* @Actions). Each entry's key is the @Action's
* name (the method name by default), and the value is an
* {@link ApplicationAction} that calls the @Actions method.
* For example, the code below prints "Hello World":
*
* If a ResourceMap is provided then each
* ApplicationAction's ({@link javax.swing.Action#putValue
* putValue}, {@link javax.swing.Action#getValue getValue}) properties
* are initialized from the ResourceMap.
*
* @see ApplicationAction
* @see ResourceMap
* @author Hans Muller (Hans.Muller@Sun.COM)
*/
public class ApplicationActionMap extends ActionMap {
private final ApplicationContext context;
private final ResourceMap resourceMap;
private final Class actionsClass;
private final Object actionsObject;
private final List
* The created action map will contain actions which are defined in the {@code actionsObject} and all
* its ancestors up to the {@code actionsClass}. If {@code actionsClass} is a type of the {@code actionsObject} then
* actions only from this class will be added to the map.
*
* @param context the Application context
* @param actionsClass a super class for the {@code actionsObject}. Actions will be retrieved starting from this class.
* @param actionsObject the object to be scanned for the actions.
* @param resourceMap the {@code ResourceMap} to be used for those actions
*/
public ApplicationActionMap(ApplicationContext context, Class actionsClass, Object actionsObject, ResourceMap resourceMap) {
if (context == null) {
throw new IllegalArgumentException("null context");
}
if (actionsClass == null) {
throw new IllegalArgumentException("null actionsClass");
}
if (actionsObject == null) {
throw new IllegalArgumentException("null actionsObject");
}
if (!(actionsClass.isInstance(actionsObject))) {
throw new IllegalArgumentException("actionsObject not an instanceof actionsClass");
}
this.context = context;
this.actionsClass = actionsClass;
this.actionsObject = actionsObject;
this.resourceMap = resourceMap;
this.proxyActions = new ArrayList
* Returns a read-only list of the {@code @ProxyActions} defined
* by this {@code ApplicationActionMap's} {@code actionClass}
* and, recursively, by this {@code ApplicationActionMap's} parent.
* If there are no proxyActions, an empty list is returned.
*
* @return a list of all the proxyActions for this {@code ApplicationActionMap}
*/
public List
* {@link Application Applications} use {@code ApplicationContext},
* via {@link Application#getContext}, to access global values and services.
* The majority of the Swing Application Framework API can be accessed through {@code
* ApplicationContext}.
*
* @see Application
* @author Hans Muller (Hans.Muller@Sun.COM)
*/
public class ApplicationContext extends AbstractBean {
private static final Logger logger = Logger.getLogger(ApplicationContext.class.getName());
private final List
* This method is only intended for testing, or design time
* configuration. Normal applications shouldn't need to
* call it directly.
*
* @param applicationClass
* @see #getApplicationClass
*/
public final synchronized void setApplicationClass(Class applicationClass) {
if (this.application != null) {
throw new IllegalStateException("application has been launched");
}
this.applicationClass = applicationClass;
}
/**
* The {@code Application} singleton, or null if {@code launch} hasn't
* been called yet.
*
* @return the launched Application singleton.
* @see Application#launch
*/
public final synchronized Application getApplication() {
return application;
}
/* Called by Application.launch().
*/
synchronized void setApplication(Application application) {
if (this.application != null) {
throw new IllegalStateException("application has already been launched");
}
this.application = application;
}
/**
* The application's {@code ResourceManager} provides
* read-only cached access to resources in ResourceBundles via the
* {@link ResourceMap ResourceMap} class.
*
* @return this application's ResourceManager.
* @see #getResourceMap(Class, Class)
*/
public final ResourceManager getResourceManager() {
return resourceManager;
}
/**
* Change this application's {@code ResourceManager}. An
* {@code ApplicationContext} subclass that
* wanted to fundamentally change the way {@code ResourceMaps} were
* created and cached could replace this property in its constructor.
*
* Throws an IllegalArgumentException if resourceManager is null.
*
* @param resourceManager the new value of the resourceManager property.
* @see #getResourceMap(Class, Class)
* @see #getResourceManager
*/
protected void setResourceManager(ResourceManager resourceManager) {
if (resourceManager == null) {
throw new IllegalArgumentException("null resourceManager");
}
Object oldValue = this.resourceManager;
this.resourceManager = resourceManager;
firePropertyChange("resourceManager", oldValue, this.resourceManager);
}
/**
* Returns a {@link ResourceMap#getParent chain} of two or
* more ResourceMaps. The first encapsulates the ResourceBundles
* defined for the specified class, and its parent
* encapsulates the ResourceBundles defined for the entire application.
*
* This is just a convenience method that calls
* {@link ResourceManager#getResourceMap(Class, Class)
* ResourceManager.getResourceMap()}. It's defined as:
*
* This is just a convenience method that calls
* {@link ResourceManager#getResourceMap(Class, Class)
* ResourceManager.getResourceMap()}. It's defined as:
*
* This is just a convenience method that calls
* {@link ResourceManager#getResourceMap()
* ResourceManager.getResourceMap()}. It's defined as:
*
* Throws an IllegalArgumentException if actionManager is null.
*
* @param actionManager the new value of the actionManager property.
* @see #getActionManager
* @see #getActionMap(Object)
*/
protected void setActionManager(ActionManager actionManager) {
if (actionManager == null) {
throw new IllegalArgumentException("null actionManager");
}
Object oldValue = this.actionManager;
this.actionManager = actionManager;
firePropertyChange("actionManager", oldValue, this.actionManager);
}
/**
* Returns the shared {@code ActionMap} chain for the entire {@code Application}.
*
* This is just a convenience method that calls
* {@link ActionManager#getActionMap()
* ActionManager.getActionMap()}. It's defined as:
*
* This is just a convenience method that calls
* {@link ActionManager#getActionMap()
* ActionManager.getActionMap(Class, Object)}. It's defined as:
*
* This method may be called at any time; the JFrame is created lazily
* and cached. For example:
*
* This method should be called from the startup method by a
* subclass that wants to construct and initialize the main frame
* itself. Most applications can rely on the fact that {code
* getFrame} lazily constructs the main frame and initializes
* the {@code frame} property.
*
* If the main frame property was already initialized, either
* implicitly through a call to {@code getFrame} or by
* explicitly calling this method, an IllegalStateException is
* thrown. If {@code frame} is null, an IllegalArgumentException
* is thrown.
*
* This property is bound.
*
*
*
* @param frame the new value of the frame property
* @see #getFrame
*/
public void setFrame(JFrame frame) {
if (frame == null) {
throw new IllegalArgumentException("null JFrame");
}
if (this.frame != null) {
throw new IllegalStateException("frame already set");
}
this.frame = frame;
firePropertyChange("frame", null, this.frame);
}
@Override
public JRootPane getRootPane() {
return getFrame().getRootPane();
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/LocalStorage.java 0000664 0000000 0000000 00000052464 11516403062 0025102 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.application;
import static org.jdesktop.application.Application.KEY_APPLICATION_VENDOR_ID;
import org.jdesktop.application.utils.AppHelper;
import org.jdesktop.application.utils.PlatformType;
import javax.jnlp.*;
import java.awt.*;
import java.beans.*;
import java.io.*;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Access to per application, per user, local file storage.
*
* @see ApplicationContext#getLocalStorage
* @see SessionStorage
* @author Hans Muller (Hans.Muller@Sun.COM)
*/
public class LocalStorage extends AbstractBean {
private static Logger logger = Logger.getLogger(LocalStorage.class.getName());
private final ApplicationContext context;
private long storageLimit = -1L;
private LocalIO localIO = null;
private final File unspecifiedFile = new File("unspecified");
private File directory = unspecifiedFile;
protected LocalStorage(ApplicationContext context) {
if (context == null) {
throw new IllegalArgumentException("null context");
}
this.context = context;
}
// FIXME - documentation
protected final ApplicationContext getContext() {
return context;
}
private void checkFileName(String fileName) {
if (fileName == null) {
throw new IllegalArgumentException("null fileName");
}
}
/**
* Opens an input stream to read from the entry
* specified by the {@code name} parameter.
* If the named entry cannot be opened for reading
* then a {@code IOException} is thrown.
*
* @param fileName the storage-dependent name
* @return an {@code InputStream} object
* @throws IOException if the specified name is invalid,
* or an input stream cannot be opened
*/
public InputStream openInputFile(String fileName) throws IOException {
checkFileName(fileName);
return getLocalIO().openInputFile(fileName);
}
/**
* Opens an output stream to write to the entry
* specified by the {@code name} parameter.
* If the named entry cannot be opened for writing
* then a {@code IOException} is thrown.
* If the named entry does not exist it can be created.
* The entry will be recreated if already exists.
*
* @param fileName the storage-dependent name
* @return an {@code OutputStream} object
* @throws IOException if the specified name is invalid,
* or an output stream cannot be opened
*/
public OutputStream openOutputFile(final String fileName) throws IOException {
return openOutputFile(fileName, false);
}
/**
* Opens an output stream to write to the entry
* specified by the {@code name} parameter.
* If the named entry cannot be opened for writing
* then a {@code IOException} is thrown.
* If the named entry does not exist it can be created.
* You can decide whether data will be appended via append parameter.
*
* @param fileName the storage-dependent name
* @param append if
*/
class MnemonicText {
private MnemonicText() {
} // not used
public static void configure(Object target, String markedText) {
String text = markedText;
int mnemonicIndex = -1;
int mnemonicKey = KeyEvent.VK_UNDEFINED;
// TBD: mnemonic marker char should be an application resource
int markerIndex = mnemonicMarkerIndex(markedText, '&');
if (markerIndex == -1) {
markerIndex = mnemonicMarkerIndex(markedText, '_');
}
if (markerIndex != -1) {
text = text.substring(0, markerIndex) + text.substring(markerIndex + 1);
mnemonicIndex = markerIndex;
CharacterIterator sci = new StringCharacterIterator(markedText, markerIndex);
mnemonicKey = mnemonicKey(sci.next());
}
if (target instanceof javax.swing.Action) {
configureAction((javax.swing.Action) target, text, mnemonicKey, mnemonicIndex);
} else if (target instanceof AbstractButton) {
configureButton((AbstractButton) target, text, mnemonicKey, mnemonicIndex);
} else if (target instanceof JLabel) {
configureLabel((JLabel) target, text, mnemonicKey, mnemonicIndex);
} else {
throw new IllegalArgumentException("unrecognized target type " + target);
}
}
private static int mnemonicMarkerIndex(String s, char marker) {
if ((s == null) || (s.length() < 2)) {
return -1;
}
CharacterIterator sci = new StringCharacterIterator(s);
int i = 0;
while (i != -1) {
i = s.indexOf(marker, i);
if (i != -1) {
sci.setIndex(i);
char c1 = sci.previous();
sci.setIndex(i);
char c2 = sci.next();
boolean isQuote = (c1 == '\'') && (c2 == '\'');
boolean isSpace = Character.isWhitespace(c2);
if (!isQuote && !isSpace && (c2 != CharacterIterator.DONE)) {
return i;
}
}
if (i != -1) {
i += 1;
}
}
return -1;
}
/* A general purpose way to map from a char to a KeyCode is needed. An
* AWT RFE has been filed:
* http://bt2ws.central.sun.com/CrPrint?id=6559449
* CR 6559449 java/classes_awt Support for converting from char to KeyEvent VK_ keycode
*/
private static int mnemonicKey(char c) {
int vk = (int) c;
if ((vk >= 'a') && (vk <= 'z')) {
vk -= ('a' - 'A');
}
return vk;
}
/* This javax.swing.Action constants is only
* defined in Mustang (1.6), see
* http://download.java.net/jdk6/docs/api/javax/swing/Action.html
*/
private static final String DISPLAYED_MNEMONIC_INDEX_KEY = "SwingDisplayedMnemonicIndexKey";
private static void configureAction(javax.swing.Action target, String text, int key, int index) {
target.putValue(javax.swing.Action.NAME, text);
if (key != KeyEvent.VK_UNDEFINED) {
target.putValue(javax.swing.Action.MNEMONIC_KEY, key);
}
if (index != -1) {
target.putValue(DISPLAYED_MNEMONIC_INDEX_KEY, index);
}
}
private static void configureButton(AbstractButton target, String text, int key, int index) {
target.setText(text);
if (key != KeyEvent.VK_UNDEFINED) {
target.setMnemonic(key);
}
if (index != -1) {
target.setDisplayedMnemonicIndex(index);
}
}
private static void configureLabel(JLabel target, String text, int key, int index) {
target.setText(text);
if (key != KeyEvent.VK_UNDEFINED) {
target.setDisplayedMnemonic(key);
}
if (index != -1) {
target.setDisplayedMnemonicIndex(index);
}
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/ProxyActions.java 0000664 0000000 0000000 00000003203 11516403062 0025150 0 ustar 00root root 0000000 0000000
/*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.application;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Defines a list of the proxy action names
*
* The proxy actions perform their
* action not on the component they're bound to (menu items and
* toolbar buttons), but on the component that currently
* has the keyboard focus. Their enabled state tracks the
* selection value of the component with the keyboard focus,
* as well as the contents of the system clipboard.
* The proxy actions work in conjunction with the action
* map associated with the component that has focus.
*
* So you can create an action in any object (whether it is a component or not),
* and use that action anywhere. But as the focus changes, that one action binds
* itself to the same named action in the component tree that the focused control has.
*
* For example, in the case of Copy, the proxy action can be created anywhere
* in the application and attached to menus, buttons, or whatever you want.
* When the focus is on a control that has an ActionMap that contains a 'copy' entry,
* the proxy action will bind to that action and the menu/button/whatever will invoke
* the action of the component with focus.
*
* @author Hans Muller (Hans.Muller@Sun.COM)
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ProxyActions {
String[] value() default {};
}
bsaf-1.9/src/main/java/org/jdesktop/application/Resource.java 0000664 0000000 0000000 00000001643 11516403062 0024303 0 ustar 00root root 0000000 0000000
/*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.application;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Marks the field as a resource to be injected.
*
* In order to inject the resources for this class,
* the resources must be defined in a class resource file.
* You should name field resources in the resource file using the class name followed by a period (.) and the key:
*
* The supportsType method defines what types a ResourceConverter supports.
* By default it returns true for classes that are equal to the constructor's
* type argument. The parseType methods converts a string
* the ResourceConverter's supported type, and the toString does the
* inverse, it converts a supported type to a String. Concrete ResourceConverter
* subclasses must override parseType() and, in most cases, the
* toString method as well.
*
* This class maintains a registry of ResourceConverters.
* The forType method returns the first ResourceConverter that
* supports a particular type, new ResourceConverters can be added with
* register(). A small set of generic ResourceConverters are
* registered by default. They support the following types:
*
* The Boolean ResourceConverter returns true for "true", "on", "yes",
* false otherwise. The other primitive type ResourceConverters rely on
* the corresponding static parseType method,
* e.g. Integer.parseInt(). The MessageFormat
* ResourceConverter just creates MessageFormat object with the string
* as its constructor argument. The URL/URI converters just apply
* the corresponding constructor to the resource string.
*
* @author Hans Muller (Hans.Muller@Sun.COM)
* @see ResourceMap
*/
public abstract class ResourceConverter {
protected final Class type;
/**
* Convert string to object
* @param s the string to be parsed
* @param r the {@code ResourceMap}
* @return the object which was created from the string
* @throws org.jdesktop.application.ResourceConverter.ResourceConverterException
*/
public abstract Object parseString(String s, ResourceMap r)
throws ResourceConverterException;
/**
* Null safe toString operation.
* @param obj the object to be converted to String
* @return result of obj.toString or "null"
*/
public String toString(Object obj) {
return (obj == null) ? "null" : obj.toString();
} //TODO: it should be static, or even moved to the utility class
protected ResourceConverter(Class type) {
if (type == null) {
throw new IllegalArgumentException("null type");
}
this.type = type;
}
private ResourceConverter() {
type = null;
} // not used
/**
* Checks whether {@code testType} can be converted with this converter.
* @param testType
* @return {@code true} if {@code testType} can be converted with this converter.
*/
public boolean supportsType(Class testType) {
return type.equals(testType);
}
public static class ResourceConverterException extends Exception {
private final String badString;
private String maybeShorten(String s) {
int n = s.length();
return (n < 128) ? s : s.substring(0, 128) + "...[" + (n - 128) + " more characters]";
}
public ResourceConverterException(String message, String badString, Throwable cause) {
super(message, cause);
this.badString = maybeShorten(badString);
}
public ResourceConverterException(String message, String badString) {
super(message);
this.badString = maybeShorten(badString);
}
@Override
public String toString() {
StringBuffer sb = new StringBuffer(super.toString());
sb.append(" string: \"");
sb.append(badString);
sb.append("\"");
return sb.toString();
}
}
/**
* Registers a {@code ResourceConverter}
* @param resourceConverter the resource converter to be registered
*/
public static void register(ResourceConverter resourceConverter) {
if (resourceConverter == null) {
throw new IllegalArgumentException("null resourceConverter");
}
resourceConverters.add(resourceConverter);
}
/**
* Returns {@code ResourceConverter} for the specified type
* @param type the type converter must be found for
* @return the converter for specified type or {@code null} if no converter is found for the {@code type}
*/
public static ResourceConverter forType(Class type) {
if (type == null) {
throw new IllegalArgumentException("null type");
}
for (ResourceConverter sc : resourceConverters) {
if (sc.supportsType(type)) {
return sc;
}
}
return null;
}
private static ResourceConverter[] resourceConvertersArray = {
new BooleanResourceConverter("true", "on", "yes"),
new IntegerResourceConverter(),
new MessageFormatResourceConverter(),
new FloatResourceConverter(),
new DoubleResourceConverter(),
new LongResourceConverter(),
new ShortResourceConverter(),
new ByteResourceConverter(),
new URLResourceConverter(),
new URIResourceConverter()
};
private static List
* Resources for a class are defined by an eponymous {@code ResourceBundle}
* in a {@code resources} subpackage. The Application class itself
* may also provide resources. A complete
* description of the naming conventions for ResourceBundles is provided
* by the {@link #getResourceMap(Class) getResourceMap()} method.
*
* The mapping from classes and {@code Application} to a list
* ResourceBundle names is handled by two protected methods:
* {@link #getClassBundleNames(Class) getClassBundleNames},
* {@link #getApplicationBundleNames() getApplicationBundleNames}.
* Subclasses could override these methods to append additional
* ResourceBundle names to the default lists.
*
* @see ApplicationContext#getResourceManager
* @see ApplicationContext#getResourceMap
* @see ResourceMap
* @author Hans Muller (Hans.Muller@Sun.COM)
*/
public class ResourceManager extends AbstractBean {
private static final Logger logger = Logger.getLogger(ResourceManager.class.getName());
private final Map
* The ResourceBundle names for the chain of ResourceMaps
* are defined by {@link #getClassBundleNames} and
* {@link #getApplicationBundleNames}. Collectively they define the
* standard location for {@code ResourceBundles} for a particular
* class as the {@code resources} subpackage. For example, the
* ResourceBundle for the single class {@code com.myco.MyScreen}, would
* be named {@code com.myco.resources.MyScreen}. Typical
* ResourceBundles are ".properties" files, so: {@code
* com/foo/bar/resources/MyScreen.properties}. The following table
* is a list of the ResourceMaps and their constituent
* ResourceBundles for the same example:
*
* Note that inner classes are searched for by "simple" name - eg,
* for a class MyApp$InnerClass, the resource bundle must be named
* InnerClass.properties. See the notes on {@link #classBundleBaseName classBundleBaseName}
* None of the ResourceBundles are required to exist. If more than one
* ResourceBundle contains a resource with the same name then
* the one earlier in the list has precedence
*
* ResourceMaps are constructed lazily and cached. One ResourceMap
* is constructed for each sequence of classes in the same package.
*
* @param startClass the first class whose ResourceBundles will be included
* @param stopClass the last class whose ResourceBundles will be included
* @return a {@code ResourceMap} chain that contains resources loaded from
* {@code ResourceBundles} found in the resources subpackage for
* each class.
* @see #getClassBundleNames
* @see #getApplicationBundleNames
* @see ResourceMap#getParent
* @see ResourceMap#getBundleNames
*/
public ResourceMap getResourceMap(Class startClass, Class stopClass) {
if (startClass == null) {
throw new IllegalArgumentException("null startClass");
}
if (stopClass == null) {
throw new IllegalArgumentException("null stopClass");
}
if (!stopClass.isAssignableFrom(startClass)) {
throw new IllegalArgumentException("startClass is not a subclass, or the same as, stopClass");
}
return getClassResourceMap(startClass, stopClass);
}
/**
* Return the ResourcedMap chain for the specified class. This is
* just a convenince method, it's the same as:
*
* The default value for this property is a list of {@link
* #getClassBundleNames per-class} ResourceBundle names, beginning
* with the {@code Application's} class and of each of its
* superclasses, up to {@code Application.class}.
* For example, if the Application's class was
* {@code com.foo.bar.MyApp}, and MyApp was a subclass
* of {@code SingleFrameApplication.class}, then the
* ResourceBundle names would be:
*
* The default value of this property is computed lazily and
* cached. If it's reset, then all ResourceMaps cached by
* {@code getResourceMap} will be updated.
*
* @return names of the ResourceBundles
* @see #setApplicationBundleNames
* @see #getResourceMap
* @see #getClassBundleNames
* @see ApplicationContext#getApplication
*/
public List
* By default this method returns one ResourceBundle
* whose name is the same as the class's name, but in the
* {@code "resources"} subpackage.
*
* For example, given a class named
* {@code com.foo.bar.MyClass}, the ResourceBundle name would
* be {@code "com.foo.bar.resources.MyClass"}. If MyClass is
* an inner class, only its "simple name" is used. For example,
* given an inner class named {@code com.foo.bar.OuterClass$InnerClass},
* the ResourceBundle name would be
* {@code "com.foo.bar.resources.InnerClass"}.
*
* This method is used by the {@code getResourceMap} methods
* to compute the list of ResourceBundle names
* for a new {@code ResourceMap}. ResourceManager subclasses
* can override this method to add additional class-specific
* ResourceBundle names to the list.
*
* @param cls the named ResourceBundles are specific to {@code cls}.
* @return the names of the ResourceBundles to be loaded for {@code cls}
* @see #getResourceMap
* @see #getApplicationBundleNames
*/
protected List
* By default the value of this resource is "osx" if the
* underlying operating environment is Apple OSX or "default".
* To distinguish other platforms one can reset this property
* based on the value of the {@code "os.name"} system property.
*
* This method should be called as early as possible, typically
* in the Application {@link Application#initialize initialize}
* method.
*
* @param platform
* @see #getPlatform
* @see System#getProperty
*/
public void setPlatform(PlatformType platform) {
if (platform == null) {
throw new IllegalArgumentException("null platform");
}
getResourceMap().setPlatform(platform);
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/ResourceMap.java 0000664 0000000 0000000 00000175000 11516403062 0024740 0 ustar 00root root 0000000 0000000
/*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.application;
import org.jdesktop.application.ResourceConverter.ResourceConverterException;
import org.jdesktop.application.utils.PlatformType;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.Font;
import java.awt.Image;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.AbstractButton;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.KeyStroke;
import javax.swing.border.EmptyBorder;
/**
* A read-only encapsulation of one or more ResourceBundles that adds
* automatic string conversion, support for field and Swing component
* property injection, string resource variable substitution, and chaining.
*
* ResourceMaps are typically obtained with the {@code ApplicationContext}
* {@link ApplicationContext#getResourceMap getResourceMap} method
* which lazily creates per Application, package, and class ResourceMaps that
* are linked together with the ResourceMap parent property.
*
* An individual ResourceMap provides read-only access to all of the
* resources defined by the ResourceBundles named when the ResourceMap
* was created as well as all of its parent ResourceMaps. Resources
* are retrieved with the getObject method which requires both
* the name of the resource and its expected type. The latter is used
* to convert strings if neccessary.
* Converted values are cached. As a convenience, getObject
* wrapper methods for common GUI types, like getFont,
* and getColor, are provided.
*
* The getObject method scans raw string resource values
* for ${resourceName} variable substitutions before
* performing string conversion. Variables named this way can
* refer to String resources defined anywhere in their ResourceMap
* or any parent ResourceMap. The special variable ${null}
* means that the value of the resource will be null.
*
* ResourceMaps can be used to "inject" resource values into Swing
* component properties and into object fields. The
* injectComponents method uses Component names ({@link
* Component#setName}) to match resources names with properties. The
* injectFields method sets fields that have been tagged with
* the @Resource annotation to the value of resources
* with the same name.
*
* @author Hans Muller (Hans.Muller@Sun.COM)
* @see #injectComponents
* @see #injectFields
* @see ResourceConverter
* @see ResourceBundle
*/
public class ResourceMap {
private static Logger logger = Logger.getLogger(ResourceMap.class.getName());
public static final String KEY_PLATFORM = "platform";
private final static Object NULL_RESOURCE = "null resource";
private final ClassLoader classLoader;
private final ResourceMap parent;
private final List
* ResourceBundles are loaded with the specified ClassLoader. If
* classLoader is null, an IllegalArgumentException is
* thrown.
*
* At least one bundleName must be specified and all of the
* bundleNames must be non-empty strings, or an
* IllegalArgumentException is thrown. The bundles are
* listed in priority order, highest priority first. In other
* words, resources in the the first ResourceBundle named first,
* shadow resources with the same name later in the list.
*
* All of the bundleNames
* must share a common package prefix. The package prefix
* implicitly specifies the resources directory
* (see {@link #getResourcesDir}). For example, the resources
* directory for bundle names "myapp.resources.foo" and
* "myapp.resources.bar", would be "myapp/resources/". If
* bundle names don't share a common package prefix, then
* an IllegalArgumentException is thrown.
*
* @param parent parent ResourceMap or null
* @param classLoader the ClassLoader to be used to load the ResourceBundle
* @param bundleNames names of the ResourceBundle to be loaded
* @throws IllegalArgumentException if classLoader or any bundleName is
* null, if no bundleNames are specified, if any bundleName is an
* empty (zero length) String, or if all of the bundleNames don't
* have a common package prefix
* @see ResourceBundle
* @see #getParent
* @see #getClassLoader
* @see #getResourcesDir
* @see #getBundleNames
*/
public ResourceMap(ResourceMap parent, ClassLoader classLoader, List
* The protected {@code getResource}, {@code putResource}, and
* {@code containsResourceKey}, {@code getResourceKeySet} abstract
* the internal representation of this ResourceMap's list of
* {@code ResourceBundles}. Most applications can ignore them.
*
* @return the names of the resources defined in this ResourceMap
* @see #getResource
* @see #putResource
* @see #containsResourceKey
*/
protected Set
* The protected {@code getResource}, {@code putResource}, and
* {@code containsResourceKey}, {@code getResourceKeySet} abstract
* the internal representation of this ResourceMap's list of
* {@code ResourceBundles}. Most applications can ignore them.
*
* If {@code key} is null, an IllegalArgumentException is thrown.
*
* @param key the name of the resource
* @return true if a resource named {@code key} is defined in this ResourceMap
* @see #getResource
* @see #putResource
* @see #getResourceKeySet
*/
protected boolean containsResourceKey(String key) {
checkNullKey(key);
Map
* The protected {@code getResource}, {@code putResource}, and
* {@code containsResourceKey}, {@code getResourceKeySet} abstract
* the internal representation of this ResourceMap's list of
* {@code ResourceBundles}. Most applications can ignore them.
*
* If {@code key} is null, an IllegalArgumentException is thrown.
*
* @param key the name of the resource
* @return the value of the resource named {@code key} (can be null)
* @see #putResource
* @see #containsResourceKey
* @see #getResourceKeySet
*/
protected Object getResource(String key) {
checkNullKey(key);
Map
* The protected {@code getResource}, {@code putResource}, and
* {@code containsResourceKey}, {@code getResourceKeySet} abstract
* the internal representation of this ResourceMap's list of
* {@code ResourceBundles}. Most applications can ignore them.
*
* If {@code key} is null, an IllegalArgumentException is thrown.
*
* @param key the name of the resource
* @param value the value of the resource (can be null)
* @see #getResource
* @see #containsResourceKey
* @see #getResourceKeySet
*/
protected void putResource(String key, Object value) {
checkNullKey(key);
if (KEY_PLATFORM.equals(key)) {
setPlatform((PlatformType) value);
} else {
Map
* String resources may contain variables that name other
* resources. Each ${variable-key} variable is replaced
* with the value of a string resource named
* variable-key. For example, given the following
* resources:
*
* The value returned by getObject will be of the specified type. If a
* string valued resource exists for key, and type is not
* String.class, the value will be converted using a
* ResourceConverter and the ResourceMap entry updated with the
* converted value.
*
* If the named resource exists and an error occurs during lookup,
* then a ResourceMap.LookupException is thrown. This can
* happen if string conversion fails, or if resource parameters
* can't be evaluated, or if the existing resource is of the wrong
* type.
*
* An IllegalArgumentException is thrown if key or type are null.
*
* @param key resource name
* @param type resource type
* @return the value of the resource
* @see #getParent
* @see ResourceConverter#forType
* @see ResourceMap.LookupException
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key or type are null
*/
public Object getObject(String key, Class type) {
checkNullKey(key);
if (type == null) {
throw new IllegalArgumentException("null type");
}
if (type.isPrimitive()) {
if (type == Boolean.TYPE) {
type = Boolean.class;
} else if (type == Character.TYPE) {
type = Character.class;
} else if (type == Byte.TYPE) {
type = Byte.class;
} else if (type == Short.TYPE) {
type = Short.class;
} else if (type == Integer.TYPE) {
type = Integer.class;
} else if (type == Long.TYPE) {
type = Long.class;
} else if (type == Float.TYPE) {
type = Float.class;
} else if (type == Double.TYPE) {
type = Double.class;
}
}
Object value = null;
ResourceMap resourceMapNode = this;
/* Find the ResourceMap bundlesMap that contains a non-null
* value for the specified key, first check this ResourceMap,
* then its parents.
*/
while (resourceMapNode != null) {
if (resourceMapNode.containsResourceKey(key)) {
value = resourceMapNode.getResource(key);
break;
}
resourceMapNode = resourceMapNode.getParent();
}
/* If we've found a String expression then replace
* any ${key} variables, and then reset the
* the original resourceMapNode entry.
*/
if ((value instanceof String) && ((String) value).contains("${")) {
value = evaluateStringExpression((String) value);
resourceMapNode.putResource(key, value);
}
/* If the value we've found in resourceMapNode is
* the expected type, then we're done. If the expected
* type is primitive and the value is the corresponding
* object type then we're done too. Otherwise,
* if it's a String, then try and convert the String
* and replace the original resourceMapNode entry,
* otherwise return null.
*/
if (value != null) {
Class valueClass = value.getClass();
if (!type.isAssignableFrom(valueClass)) {
if (value instanceof String) {
ResourceConverter stringConverter = ResourceConverter.forType(type);
if (stringConverter != null) {
String sValue = (String) value;
try {
value = stringConverter.parseString(sValue, resourceMapNode);
resourceMapNode.putResource(key, value);
} catch (ResourceConverterException e) {
String msg = "string conversion failed";
LookupException lfe = new LookupException(msg, key, type);
lfe.initCause(e);
throw lfe;
}
} else {
String msg = "no StringConverter for required type";
throw new LookupException(msg, key, type);
}
} else {
String msg = "named resource has wrong type";
throw new LookupException(msg, key, type);
}
}
}
return value;
}
/* Given the following resources:
*
* hello = Hello
* world = World
* place = ${world}
*
* The value of evaluateStringExpression("${hello} ${place}")
* would be "Hello World". The value of ${null} is null.
*/
private String evaluateStringExpression(String expr) {
if (expr.trim().equals("${null}")) {
return null;
}
StringBuffer value = new StringBuffer();
int i0 = 0, i1;
while ((i1 = expr.indexOf("${", i0)) != -1) {
if ((i1 == 0) || ((i1 > 0) && (expr.charAt(i1 - 1) != '\\'))) {
int i2 = expr.indexOf("}", i1);
if ((i2 != -1) && (i2 > i1 + 2)) {
String k = expr.substring(i1 + 2, i2);
String v = getString(k);
value.append(expr.substring(i0, i1));
if (v != null) {
value.append(v);
} else {
String msg = String.format("no value for \"%s\" in \"%s\"", k, expr);
throw new LookupException(msg, k, String.class);
}
i0 = i2 + 1; // skip trailing "}"
} else {
String msg = String.format("no closing brace in \"%s\"", expr);
throw new LookupException(msg, "
* If the resource named key is a String, it should name
* an image file to be found in the resources subdirectory that
* also contains the ResourceBundle (typically a ".properties"
* file) that was used to create the corresponding ResourceMap.
*
* For example, given the ResourceMap produced by
* Application.getClass(com.mypackage.MyClass.class),
* and a ResourceBundle called MyClass.properties
* in com.mypackage.resources:
*
* For example, given a button configured like this:
*
* This method calls {@link #getObject} to look up resources
* and it uses {@link Introspector#getBeanInfo} to find
* the target component's properties.
*
* If target is null an IllegalArgumentException is thrown. If a
* resource is found that matches the target component's name but
* the corresponding property can't be set, an (unchecked) {@link
* PropertyInjectionException} is thrown.
*
*
*
* @param target the Component to inject
* @see #injectComponents
* @see #getObject
* @see ResourceConverter#forType
* @throws LookupException if an error occurs during lookup or string conversion
* @throws PropertyInjectionException if a property specified by a resource can't be set
* @throws IllegalArgumentException if target is null
*/
public void injectComponent(Component target) {
if (target == null) {
throw new IllegalArgumentException("null target");
}
injectComponentProperties(target);
}
/**
* Applies {@link #injectComponent} to each Component in the
* hierarchy with root root.
*
* @param root the root of the component hierarchy
* @throws PropertyInjectionException if a property specified by a resource can't be set
* @throws IllegalArgumentException if target is null
* @see #injectComponent
*/
public void injectComponents(Component root) {
injectComponent(root);
if (root instanceof JMenu) {
/* Warning: we're bypassing the popupMenu here because
* JMenu#getPopupMenu creates it; doesn't seem right
* to do so at injection time. Unfortunately, this
* means that attempts to inject the popup menu's
* "label" property will fail.
*/
JMenu menu = (JMenu) root;
for (Component child : menu.getMenuComponents()) {
injectComponents(child);
}
} else if (root instanceof Container) {
Container container = (Container) root;
for (Component child : container.getComponents()) {
injectComponents(child);
}
}
}
/**
* Unchecked exception thrown by {@link #injectFields} when
* an error occurs while attempting to set a field (a field that
* had been marked with @Resource).
*
* @see #injectFields
*/
public static class InjectFieldException extends RuntimeException {
private final Field field;
private final Object target;
private final String key;
/**
* Constructs an instance of this class with some useful information
* about the failure.
*
* @param msg the detail message
* @param field the Field we were attempting to set
* @param target the object whose field we were attempting to set
* @param key the name of the resource
*/
public InjectFieldException(String msg, Field field, Object target, String key) {
super(String.format("%s: resource %s, field %s, target %s", msg, key, field, target));
this.field = field;
this.target = target;
this.key = key;
}
/**
* Return the Field whose value couldn't be set.
* @return the field whose value couldn't be set
*/
public Field getField() {
return field;
}
/**
* Return the Object whose Field we were attempting to set
* @return the Object whose Field we were attempting to set
*/
public Object getTarget() {
return target;
}
/**
* Returns the type of the name of resource for which lookup failed.
* @return the resource name
*/
public String getKey() {
return key;
}
}
private void injectField(Field field, Object target, String key) {
Class type = field.getType();
if (type.isArray()) {
type = type.getComponentType();
Pattern p = Pattern.compile(key + "\\[([\\d]+)\\]"); // matches key[12]
for (String arrayElementKey : keySet()) {
Matcher m = p.matcher(arrayElementKey);
if (m.matches()) {
/* field's value is an array, arrayElementKey is a resource
* name of the form "MyClass.myArray[12]" and m.group(1)
* matches the array index. Set the index element
* of the field's array to the value of the resource.
*/
Object value = getObject(arrayElementKey, type);
if (!field.isAccessible()) {
field.setAccessible(true);
}
try {
int index = Integer.parseInt(m.group(1));
Array.set(field.get(target), index, value);
} /* Array.set throws IllegalArgumentException, ArrayIndexOutOfBoundsException
* field.get throws IllegalAccessException(Checked), IllegalArgumentException
* Integer.parseInt throws NumberFormatException (Checked)
*/ catch (Exception e) {
String msg = "unable to set array element";
InjectFieldException ife = new InjectFieldException(msg, field, target, key);
ife.initCause(e);
throw ife;
}
}
}
} else { // field is not an array
Object value = getObject(key, type);
if (value != null) {
if (!field.isAccessible()) {
field.setAccessible(true);
}
try {
field.set(target, value);
} /* Field.set throws IllegalAccessException, IllegalArgumentException,
* ExceptionInInitializerError
*/ catch (Exception e) {
String msg = "unable to set field's value";
InjectFieldException ife = new InjectFieldException(msg, field, target, key);
ife.initCause(e);
throw ife;
}
}
}
}
/**
* Set each field with a @Resource annotation in the target object,
* to the value of a resource whose name is the simple name of the target
* class followed by "." followed by the name of the field. If the
* key @Resource parameter is specified, then a resource with that name
* is used instead. Array valued fields can also be initialized
* with resources whose names end with "[index]". For example:
*
* If target is null an IllegalArgumentException is
* thrown. If an error occurs during resource lookup, then an
* unchecked LookupException is thrown. If a target field marked
* with @Resource can't be set, then an unchecked
* InjectFieldException is thrown.
*
* @param target the object whose fields will be initialized
* @throws LookupException if an error occurs during lookup or string conversion
* @throws InjectFieldException if a field can't be set
* @throws IllegalArgumentException if target is null
* @see #getObject
*/
public void injectFields(Object target) {
if (target == null) {
throw new IllegalArgumentException("null target");
}
Class targetType = target.getClass();
if (targetType.isArray()) {
throw new IllegalArgumentException("array target");
}
String keyPrefix = targetType.getSimpleName() + ".";
for (Field field : targetType.getDeclaredFields()) {
Resource resource = field.getAnnotation(Resource.class);
if (resource != null) {
String rKey = resource.key();
String key = (rKey.length() > 0) ? rKey : keyPrefix + field.getName();
injectField(field, target, key);
}
}
}
/* Register ResourceConverters that are defined in this class
* and documented here.
*/
static {
ResourceConverter[] stringConverters = {
new ColorStringConverter(),
new IconStringConverter(),
new ImageStringConverter(),
new FontStringConverter(),
new KeyStrokeStringConverter(),
new DimensionStringConverter(),
new PointStringConverter(),
new RectangleStringConverter(),
new InsetsStringConverter(),
new EmptyBorderStringConverter()
};
for (ResourceConverter sc : stringConverters) {
ResourceConverter.register(sc);
}
}
/* If path doesn't have a leading "/" then the resourcesDir
* is prepended, otherwise the leading "/" is removed.
*/
private static String resourcePath(final String path, ResourceMap resourceMap) {
if (path == null) {
return null;
} else if (path.startsWith("/")) {
return (path.length() > 1) ? path.substring(1) : null;
} else {
return resourceMap.getResourcesDir() + path;
}
}
private static ImageIcon loadImageIcon(String s, ResourceMap resourceMap)
throws ResourceConverterException {
String rPath = resourcePath(s, resourceMap);
if (rPath == null) {
String msg = String.format("invalid image/icon path \"%s\"", s);
throw new ResourceConverterException(msg, s);
}
URL url = resourceMap.getClassLoader().getResource(rPath);
if (url != null) {
return new ImageIcon(url);
} else {
String msg = String.format("couldn't find Icon resource \"%s\"", s);
throw new ResourceConverterException(msg, s);
}
}
private static class FontStringConverter extends ResourceConverter {
FontStringConverter() {
super(Font.class);
}
/* Just delegates to Font.decode.
* Typical string is: face-STYLE-size, for example "Arial-PLAIN-12"
*/
@Override
public Object parseString(String s, ResourceMap ignore) throws ResourceConverterException {
return Font.decode(s);
}
}
private static class ColorStringConverter extends ResourceConverter {
ColorStringConverter() {
super(Color.class);
}
// private void error(String msg, String s, Exception e) throws ResourceConverterException {
// throw new ResourceConverterException(msg, s, e);
// }
/* An improved version of Color.decode() that supports colors
* with an alpha channel and comma separated RGB[A] values.
* Legal format for color resources are:
* "#RRGGBB", "#AARRGGBB", "R, G, B", "R, G, B, A"
* Thanks to Romain Guy for the code.
*/
@Override
public Object parseString(String s, ResourceMap ignore) throws ResourceConverterException {
final Color color;
if (s.startsWith("#")) {
switch (s.length()) {
// RGB/hex color
case 7:
color = Color.decode(s);
break;
// ARGB/hex color
case 9:
int alpha = Integer.decode(s.substring(0, 3));
int rgb = Integer.decode("#" + s.substring(3));
color = new Color(alpha << 24 | rgb, true);
break;
default:
throw new ResourceConverterException("invalid #RRGGBB or #AARRGGBB color string", s);
}
} else {
String[] parts = s.split(",");
if (parts.length < 3 || parts.length > 4) {
throw new ResourceConverterException("invalid R, G, B[, A] color string", s);
}
try {
// with alpha component
if (parts.length == 4) {
int r = Integer.parseInt(parts[0].trim());
int g = Integer.parseInt(parts[1].trim());
int b = Integer.parseInt(parts[2].trim());
int a = Integer.parseInt(parts[3].trim());
color = new Color(r, g, b, a);
} else {
int r = Integer.parseInt(parts[0].trim());
int g = Integer.parseInt(parts[1].trim());
int b = Integer.parseInt(parts[2].trim());
color = new Color(r, g, b);
}
} catch (NumberFormatException e) {
throw new ResourceConverterException("invalid R, G, B[, A] color string", s, e);
}
}
return color;
}
}
private static class IconStringConverter extends ResourceConverter {
IconStringConverter() {
super(Icon.class);
}
@Override
public Object parseString(String s, ResourceMap resourceMap) throws ResourceConverterException {
return loadImageIcon(s, resourceMap);
}
@Override
public boolean supportsType(Class testType) {
return testType.equals(Icon.class) || testType.equals(ImageIcon.class);
}
}
private static class ImageStringConverter extends ResourceConverter {
ImageStringConverter() {
super(Image.class);
}
@Override
public Object parseString(String s, ResourceMap resourceMap) throws ResourceConverterException {
return loadImageIcon(s, resourceMap).getImage();
}
}
private static class KeyStrokeStringConverter extends ResourceConverter {
KeyStrokeStringConverter() {
super(KeyStroke.class);
}
@Override
public Object parseString(String s, ResourceMap ignore) {
if (s.contains("shortcut")) {
int k = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
s = s.replaceAll("shortcut", (k == Event.META_MASK) ? "meta" : "control");
}
return KeyStroke.getKeyStroke(s);
}
}
/* String s is assumed to contain n number substrings separated by
* commas. Return a list of those integers or null if there are too
* many, too few, or if a substring can't be parsed. The format
* of the numbers is specified by Double.valueOf().
*/
private static List
* This class simplifies the common task of saving a little bit of an
* application's GUI "session" state when the application shuts down,
* and then restoring that state when the application is restarted.
* Session state is stored on a per component basis, and only for
* components with a {@link java.awt.Component#getName name} and for
* which a {@code PropertySupport} object has been defined and registeres.
* SessionState Properties that preserve the {@code bounds} {@code Rectangle}
* for Windows, the {@code dividerLocation} for {@code JSliderPanes} and the
* {@code selectedIndex} for {@code JTabbedPanes} are defined by default. The
* {@code ApplicationContext} {@link
* ApplicationContext#getSessionStorage getSessionStorage} method
* provides a shared {@code SessionStorage} object.
*
* A typical Application saves session state in its
* {@link Application#shutdown shutdown()} method, and then restores
* session state in {@link Application#startup startup()}:
*
* Session state is stored locally, relative to the user's
* home directory, by the {@code LocalStorage}
* {@link LocalStorage#save save} and {@link LocalStorage#save load}
* methods. The {@code startup} method must set the
* {@code ApplicationContext} {@code vendorId} and {@code applicationId}
* properties to ensure that the correct
* {@link LocalStorage#getDirectory local directory} is selected on
* all platforms. For example, on Windows XP, the full pathname
* for filename {@code "session.xml"} is typically:
*
*
* Applications typically would not create a {@code SessionStorage}
* object directly, they'd use the shared ApplicationContext value:
*
* Component names can be any string however they must be unique
* relative to the name's of the component's siblings. Most Swing
* components do not have a name by default, however there are
* some exceptions: JRootPane (inexplicably) assigns names to it's
* children (layeredPane, contentPane, glassPane); and all AWT
* components lazily compute a name, so JFrame, JDialog, and
* JWindow also have a name by default.
*
* The type of sessionState values (i.e. the type of values
* returned by {@code PropertySupport.getSessionState}) must be one those
* supported by {@link java.beans.XMLEncoder XMLEncoder} and
* {@link java.beans.XMLDecoder XMLDecoder}, for example beans
* (null constructor, read/write properties), primitives, and
* Collections. Java bean classes and their properties must be
* public. Typically beans defined for this purpose are little
* more than a handful of simple properties. The JDK 6
* @ConstructorProperties annotation can be used to eliminate
* the need for writing set methods in such beans, e.g.
*
*
* @exception IllegalArgumentException if {@code cls} is null
* @param cls the class to which the returned {@code PropertySupport} applies
* @return the {@code PropertySupport} registered with {@code putProperty} for
* the specified class or the first one registered for a superclass
* of {@code cls}.
* @see #getProperty(Component)
* @see #putProperty
* @see #save
* @see #restore
*/
public PropertySupport getProperty(Class cls) {
checkClassArg(cls);
while (cls != null) {
PropertySupport p = propertyMap.get(cls);
if (p != null) {
return p;
}
cls = cls.getSuperclass();
}
return null;
}
/**
* Register a {@code PropertySupport} for the specified class.
*
* One can clear the {@code PropertySupport} for a class by setting the entry to null:
*
* The {@code putProperty} method registers a PropertySupport object for
* a class. One can specify a PropertySupport object for a single Swing
* component by setting the component's client property, like this:
*
* @exception IllegalArgumentException if {@code Component component} is null.
* @see javax.swing.JComponent#putClientProperty
* @see #getProperty(Class)
* @see #putProperty
* @see #save
* @see #restore
*/
public final PropertySupport getProperty(Component component) {
if (component == null) {
throw new IllegalArgumentException("null component");
}
if (component instanceof PropertySupport) {
return (PropertySupport) component;
} else {
PropertySupport p = null;
if (component instanceof JComponent) {
Object v = ((JComponent) component).getClientProperty(PropertySupport.class);
p = (v instanceof PropertySupport) ? (PropertySupport) v : null;
}
return (p != null) ? p : getProperty(component.getClass());
}
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/SingleFrameApplication.java 0000664 0000000 0000000 00000040116 11516403062 0027072 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved.
* Copyright (C) 2010 Illya Yalovyy. All rights reserved.
* Use is subject to license terms.
*/
package org.jdesktop.application;
import org.jdesktop.application.utils.SwingHelper;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* An application base class for simple GUIs with one primary JFrame.
*
* This class takes care of component property injection, exit processing,
* and saving/restoring session state in a way that's appropriate for
* simple single-frame applications. The application's JFrame is created
* automatically, with a WindowListener that calls exit() when the
* window is closed. Session state is stored when the application
* shuts down, and restored when the GUI is shown.
*
* To use {@code SingleFrameApplication}, one need only override
* {@code startup}, create the GUI's main panel, and apply
* {@code show} to that. Here's an example:
*
* A more realistic tiny example would rely on a ResourceBundle for
* the JLabel's string and the main frame's title. The automatic
* injection step only initializes the properties of named
* components, so:
*
* The frame's name is set to "mainFrame", its title is
* initialized with the value of the {@code Application.title}
* resource and a {@code WindowListener} is added that calls
* {@code exit} when the user attempts to close the frame.
*
*
* This method may be called at any time; the JFrame is created lazily
* and cached. For example:
*
* This method should be called from the startup method by a
* subclass that wants to construct and initialize the main frame
* itself. Most applications can rely on the fact that {code
* getMainFrame} lazily constructs the main frame and initializes
* the {@code mainFrame} property.
*
* If the main frame property was already initialized, either
* implicitly through a call to {@code getMainFrame} or by
* explicitly calling this method, an IllegalStateException is
* thrown. If {@code mainFrame} is null, an IllegalArgumentException
* is thrown.
*
* This property is bound.
*
* @param mainFrame the new value of the mainFrame property
* @see #getMainFrame
*/
protected final void setMainFrame(JFrame mainFrame) {
getMainView().setFrame(mainFrame);
}
private String sessionFilename(Window window) {
if (window == null) {
return null;
} else {
String name = window.getName();
return (name == null) ? null : name + ".session.xml";
}
}
/**
* Initialize the hierarchy with the specified root by
* injecting resources.
*
* By default the {@code show} methods
* {@link ResourceMap#injectComponents inject resources} before
* initializing the JFrame or JDialog's size, location,
* and restoring the window's session state. If the application
* is showing a window whose resources have already been injected,
* or that shouldn't be initialized via resource injection,
* this method can be overridden to defeat the default
* behavior.
*
* @param root the root of the component hierarchy
* @see ResourceMap#injectComponents
* @see #show(JComponent)
* @see #show(JFrame)
* @see #show(JDialog)
*/
protected void configureWindow(Window root) {
getContext().getResourceMap().injectComponents(root);
}
private void initRootPaneContainer(RootPaneContainer c) {
JComponent rootPane = c.getRootPane();
// These initializations are only done once
if (rootPane.getClientProperty(INITIALIZATION_MARKER) != null) {
return;
}
rootPane.putClientProperty(INITIALIZATION_MARKER, Boolean.TRUE);
// Inject resources
Container root = rootPane.getParent();
if (root instanceof Window) {
configureWindow((Window) root);
}
// If this is the mainFrame, then close == exit
JFrame mainFrame = getMainFrame();
if (c == mainFrame) {
mainFrame.addWindowListener(new MainFrameListener());
mainFrame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
} else if (root instanceof Window) { // close == save session state
Window window = (Window) root;
window.addHierarchyListener(new SecondaryWindowListener());
}
// If this is a JFrame monitor "normal" (not maximized) bounds
if (root instanceof JFrame) {
root.addComponentListener(new FrameBoundsListener());
}
if (root instanceof Window) {
Window window = (Window) root;
// If the window's bounds don't appear to have been set, do it
if (!root.isValid() || (root.getWidth() == 0) || (root.getHeight() == 0)) {
window.pack();
}
// Restore session state
String filename = sessionFilename((Window) root);
if (filename != null) {
try {
getContext().getSessionStorage().restore(root, filename);
} catch (Exception e) {
String msg = String.format("couldn't restore session [%s]", filename);
logger.log(Level.WARNING, msg, e);
}
}
// If window location is default and size is not too big
// the window should be centered
Point defaultLocation = SwingHelper.defaultLocation(window);
if (!window.isLocationByPlatform() &&
(root.getX() == defaultLocation.getX()) &&
(root.getY() == defaultLocation.getY())) {
Dimension screenSize = window.getToolkit().getScreenSize();
Dimension windowSIze = window.getSize();
if (screenSize.getWidth()/windowSIze.getWidth()>1.25 &&
screenSize.getHeight()/windowSIze.getHeight()>1.25) {
Component owner = window.getOwner();
if (owner == null) {
owner = (window != mainFrame) ? mainFrame : null;
}
window.setLocationRelativeTo(owner); // center the window
}
}
}
}
/**
* Show the specified component in the {@link #getMainFrame main frame}.
* Typical applications will call this method after constructing their
* main GUI panel in the {@code startup} method.
*
* Before the main frame is made visible, the properties of all of
* the components in the hierarchy are initialized with {@link
* ResourceMap#injectComponents ResourceMap.injectComponents} and
* then restored from saved session state (if any) with {@link
* SessionStorage#restore SessionStorage.restore}. When the
* application shuts down, session state is saved.
*
* Note that the name of the lazily created main frame (see
* {@link #getMainFrame getMainFrame}) is set by default.
* Session state is only saved for top level windows with
* a valid name and then only for component descendants
* that are named.
*
* Throws an IllegalArgumentException if {@code c} is null
*
* @param c the main frame's contentPane child
*/
protected void show(JComponent c) {
if (c == null) {
throw new IllegalArgumentException("null JComponent");
}
JFrame f = getMainFrame();
f.getContentPane().add(c, BorderLayout.CENTER);
initRootPaneContainer(f);
f.setVisible(true);
}
/**
* Initialize and show the JDialog.
*
* This method is intended for showing "secondary" windows, like
* message dialogs, about boxes, and so on. Unlike the {@code mainFrame},
* dismissing a secondary window will not exit the application.
*
* Session state is only automatically saved if the specified
* JDialog has a name, and then only for component descendants
* that are named.
*
* Throws an IllegalArgumentException if {@code c} is null
*
* @param c the main frame's contentPane child
* @see #show(JComponent)
* @see #show(JFrame)
* @see #configureWindow
*/
public void show(JDialog c) {
if (c == null) {
throw new IllegalArgumentException("null JDialog");
}
initRootPaneContainer(c);
c.setVisible(true);
}
/**
* Initialize and show the secondary JFrame.
*
* This method is intended for showing "secondary" windows, like
* message dialogs, about boxes, and so on. Unlike the {@code mainFrame},
* dismissing a secondary window will not exit the application.
*
* Session state is only automatically saved if the specified
* JFrame has a name, and then only for component descendants
* that are named.
*
* Throws an IllegalArgumentException if {@code c} is null
*
* @param c
* @see #show(JComponent)
* @see #show(JDialog)
* @see #configureWindow
*/
public void show(JFrame c) {
if (c == null) {
throw new IllegalArgumentException("null JFrame");
}
initRootPaneContainer(c);
c.setVisible(true);
}
private void saveSession(Window window) {
String filename = sessionFilename(window);
if (filename != null) {
try {
getContext().getSessionStorage().save(window, filename);
} catch (IOException e) {
logger.log(Level.WARNING, "couldn't save session", e);
}
}
}
private boolean isVisibleWindow(Window w) {
return w.isVisible() &&
((w instanceof JFrame) || (w instanceof JDialog) || (w instanceof JWindow));
}
/**
* Return all of the visible JWindows, JDialogs, and JFrames per
* Window.getWindows() on Java SE 6
*/
private List
* When a Task completes, the {@code final done} method invokes
* one of {@code succeeded}, {@code cancelled}, {@code interrupted},
* or {@code failed}. The {@code final done} method invokes
* {@code finished} when the completion method returns or throws
* an exception.
*
*
* Tasks should provide localized values for the {@code title},
* {@code description}, and {@code message} properties in a
* ResourceBundle for the Task subclass. A
* {@link ResourceMap} is
* loaded automatically using the Task subclass as the
* {@code startClass} and Task.class the {@code stopClass}.
* This ResourceMap is also used to look up format strings used in
* calls to {@link #message message}, which is used to set
* the {@code message} property.
*
*
* For example: given a Task called {@code MyTask} defined like this:
*
* Task subclasses can override resource values in their own ResourceBundles:
*
* Tasks can specify that input to the GUI is to be blocked while
* they're being executed. The {@code inputBlocker} property specifies
* what part of the GUI is to be blocked and how that's accomplished.
* The {@code inputBlocker} is set automatically when an {@code @Action}
* method that returns a Task specifies a {@link BlockingScope} value
* for the {@code block} annotation parameter. To customize the way
* blocking is implemented you can define your own {@code Task.InputBlocker}.
* For example, assume that {@code busyGlassPane} is a component
* that consumes (and ignores) keyboard and mouse input:
*
* All of the settable properties in this class are bound, i.e. a
* PropertyChangeEvent is fired when the value of the property changes.
* As with the {@code SwingWorker} superclass, all
* {@code PropertyChangeListeners} run on the event dispatching thread.
* This is also true of {@code TaskListeners}.
*
*
* Unless specified otherwise specified, this class is thread-safe.
* All of the Task properties can be get/set on any thread.
* @param
* Construct a {@code Task}. If the {@code resourceMap} parameter
* is not null, then the {@code title}, {@code description}, and
* {@code message} properties are initialized from resources. The
* {@code resourceMap} is also used to lookup localized messages
* defined with the {@link #message message} method. In both
* cases, if the value of {@code resourcePrefix} is not null or an
* empty string {@code ""}, resource names must have the name of
* the {@code resourcePrefix} parameter, followed by a ".", as a
* prefix
*
* @param application
* @param resourceMap the ResourceMap for the Task's user properties, can be null
* @param resourcePrefix prefix for resource names, can be null
* @see #getResourceMap
* @see #setTitle
* @see #setDescription
* @see #setMessage
* @see #resourceName
* @see ApplicationContext#getResourceMap
* @deprecated
*/
@Deprecated
public Task(Application application, ResourceMap resourceMap, String resourcePrefix) {
this.application = application;
initTask(resourceMap, resourcePrefix);
}
/**
* Warning: This constructor is deprecated. It will be removed
* in a future release. This constructor was a way for developers
* to initialize a Task's title/description/message properties,
* and it's InputBlocker's visual properties, from an alternative
* ResourceMap. This feature is now supported with the
* InputBlocker's resourceMap property.
*
* Construct a {@code Task} with the specified resource name
* prefix, whose ResourceMap is the value of
* This is a read-only bound property.
*
* @return the value of the taskService property.
* @see TaskService#execute
* @see #done
*/
public synchronized TaskService getTaskService() {
return taskService;
}
/**
* Set when a task is executed by a TaskService, cleared when
* the task is done and all of its completion methods have run.
*/
synchronized void setTaskService(TaskService taskService) {
TaskService oldTaskService, newTaskService;
synchronized (this) {
oldTaskService = this.taskService;
this.taskService = taskService;
newTaskService = this.taskService;
}
firePropertyChange(PROP_TASKSERVICE, oldTaskService, newTaskService);
}
/**
* Returns a Task resource name with the specified suffix. Task resource
* names are the simple name of the constructor's {@code resourceClass}
* parameter, followed by ".", followed by {@code suffix}. If the
* resourceClass parameter was null, then this method returns an empty string.
*
* This method would only be of interest to subclasses that wanted to look
* up additional Task resources (beyond {@code title}, {@code message}, etc..)
* using the same naming convention.
*
* @param suffix the resource name's suffix
* @return a Task resource name
* @see #getResourceMap
* @see #message
*/
protected final String resourceName(String suffix) {
return resourcePrefix + suffix;
}
/**
* Returns the {@code ResourceMap} used by the constructor to
* initialize the {@code title}, {@code message}, etc properties,
* and by the {@link #message message} method to look up format
* strings.
*
* @return this Task's {@code ResourceMap}
* @see #resourceName
*/
public final ResourceMap getResourceMap() {
return resourceMap;
}
/**
* Return the value of the {@code title} property.
* The default value of this property is the value of the
* {@link #getResourceMap resourceMap's} {@code title} resource.
*
* Returns a brief one-line description of the this Task that would
* be useful for describing this task to the user. The default
* value of this property is null.
*
* @return the value of the {@code title} property.
* @see #setTitle
* @see #setDescription
* @see #setMessage
*/
public synchronized String getTitle() {
return title;
}
/**
* Set the {@code title} property.
* The default value of this property is the value of the
* {@link #getResourceMap resourceMap's} {@code title} resource.
*
* The title is a brief one-line description of the this Task that
* would be useful for describing it to the user. The {@code
* title} should be specific to this Task, for example "Loading
* image sunset.png" is better than "Image Loader". Similarly the
* title isn't intended for ephemeral messages, like "Loaded 27.3%
* of sunset.png". The {@link #setMessage message} property is
* for reporting the Task's current status.
*
* @param title a brief one-line description of the this Task.
* @see #getTitle
* @see #setDescription
* @see #setMessage
*/
protected void setTitle(String title) {
String oldTitle, newTitle;
synchronized (this) {
oldTitle = this.title;
this.title = title;
newTitle = this.title;
}
firePropertyChange(PROP_TITLE, oldTitle, newTitle);
}
/**
* Return the value of the {@code description} property.
* The default value of this property is the value of the
* {@link #getResourceMap resourceMap's} {@code description} resource.
*
* A longer version of the Task's title; a few sentences that
* describe what the Task is for in terms that an application
* user would understand.
*
* @return the value of the {@code description} property.
* @see #setDescription
* @see #setTitle
* @see #setMessage
*/
public synchronized String getDescription() {
return description;
}
/**
* Set the {@code description} property.
* The default value of this property is the value of the
* {@link #getResourceMap resourceMap's} {@code description} resource.
*
* The description is a longer version of the Task's title.
* It should be a few sentences that describe what the Task is for,
* in terms that an application user would understand.
*
* @param description a few sentences that describe what this Task is for.
* @see #getDescription
* @see #setTitle
* @see #setMessage
*/
protected void setDescription(String description) {
String oldDescription, newDescription;
synchronized (this) {
oldDescription = this.description;
this.description = description;
newDescription = this.description;
}
firePropertyChange(PROP_DESCRIPTION, oldDescription, newDescription);
}
/**
* Returns the length of time this Task has run. If the task hasn't
* started yet (i.e. if its state is still {@code StateValue.PENDING}),
* then this method returns 0. Otherwise it returns the duration in the
* specified time units. For example, to learn how many seconds a
* Task has run so far:
*
* Returns a short, one-line, message that explains what the task
* is up to in terms appropriate for an application user.
*
* @return a short one-line status message.
* @see #setMessage
* @see #getMessageDuration
*/
public String getMessage() {
return message;
}
/**
* Set the {@code message} property.
* The default value of this property is the value of the
* {@link #getResourceMap resourceMap's} {@code message} resource.
*
* Returns a short, one-line, message that explains what the task is
* up to in terms appropriate for an application user. This message
* should reflect that Task's dynamic state and can be reset as
* frequently one could reasonably expect a user to understand.
* It should not repeat the information in the Task's title and
* should not convey any information that the user shouldn't ignore.
*
* For example, a Task whose {@code doInBackground} method loaded
* a photo from a web service might set this property to a new
* value each time a new internal milestone was reached, e.g.:
*
* Each time this property is set, the {@link #getMessageDuration
* messageDuration} property is reset. Since status messages are
* intended to be ephemeral, application GUI elements like status
* bars may want to clear messages after 20 or 30 seconds have
* elapsed.
*
* Localized messages that require paramters can be constructed
* with the {@link #message message} method.
*
* @param message a short one-line status message.
* @see #getMessage
* @see #getMessageDuration
* @see #message
*/
protected void setMessage(String message) {
String oldMessage, newMessage;
synchronized (this) {
oldMessage = this.message;
this.message = message;
newMessage = this.message;
messageTime = System.currentTimeMillis();
}
firePropertyChange(PROP_MESSAGE, oldMessage, newMessage);
}
/**
* Set the message property to a string generated with {@code
* String.format} and the specified arguments. The {@code
* formatResourceKey} names a resource whose value is a format
* string. See the Task class javadoc for an example.
*
* Note that if the no arguments are specified, this method is
* comparable to:
*
* If a {@code ResourceMap} was not specified for this Task,
* then set the {@code message} property to {@code formatResourceKey}.
*
* @param formatResourceKey the suffix of the format string's resource name.
* @param args the arguments referred to by the placeholders in the format string
* @see #setMessage
* @see ResourceMap#getString(String, Object...)
* @see java.text.MessageFormat
*/
protected final void message(String formatResourceKey, Object... args) {
ResourceMap resourceMap = getResourceMap();
if (resourceMap != null) {
setMessage(resourceMap.getString(resourceName(formatResourceKey), args));
} else {
setMessage(formatResourceKey);
}
}
/**
* Returns the length of time that has elapsed since the {@code
* message} property was last set.
*
* @param unit units for the return value
* @return elapsed time since the {@code message} property was last set.
* @see #setMessage
*/
public long getMessageDuration(TimeUnit unit) {
long messageTime;
synchronized (this) {
messageTime = this.messageTime;
}
long dt = (messageTime == -1L) ? 0L : Math.max(0L, System.currentTimeMillis() - messageTime);
return unit.convert(dt, TimeUnit.MILLISECONDS);
}
/**
* Returns the value of the {@code userCanCancel} property.
* The default value of this property is true.
*
* Generic GUI components, like a Task progress dialog, can use this
* property to decide if they should provide a way for the
* user to cancel this task.
*
* @return true if the user can cancel this Task.
* @see #setUserCanCancel
*/
public synchronized boolean getUserCanCancel() {
return userCanCancel;
}
/**
* Sets the {@code userCanCancel} property.
* The default value of this property is true.
*
* Generic GUI components, like a Task progress dialog, can use this
* property to decide if they should provide a way for the
* user to cancel this task. For example, the value of this
* property might be bound to the enabled property of a
* cancel button.
*
* This property has no effect on the {@link #cancel} cancel
* method. It's just advice for GUI components that display
* this Task.
*
* @param userCanCancel true if the user should be allowed to cancel this Task.
* @see #getUserCanCancel
*/
protected void setUserCanCancel(boolean userCanCancel) {
boolean oldValue, newValue;
synchronized (this) {
oldValue = this.userCanCancel;
this.userCanCancel = userCanCancel;
newValue = this.userCanCancel;
}
firePropertyChange(PROP_USERCANCANCEL, oldValue, newValue);
}
/**
* Returns true if the {@link #setProgress progress} property has
* been set. Some Tasks don't update the progress property
* because it's difficult or impossible to determine how what
* percentage of the task has been completed. GUI elements that
* display Task progress, like an application status bar, can use this
* property to set the @{link JProgressBar#indeterminate
* indeterminate} @{code JProgressBar} property.
*
* A task that does keep the progress property up to
* date should initialize it to 0, to ensure that {@code
* isProgressPropertyValid} is always true.
*
* @return true if the {@link #setProgress progress} property has been set.
* @see #setProgress
*/
public synchronized boolean isProgressPropertyValid() {
return progressPropertyIsValid;
}
/**
* A convenience method that sets the {@code progress} property to the following
* ratio normalized to 0 .. 100.
*
* When a pending Task's state changes to {@code StateValue.STARTED}
* a PropertyChangeEvent for the "started" property is fired. Similarly
* when a started Task's state changes to {@code StateValue.DONE}, a
* "done" PropertyChangeEvent is fired.
*/
public final boolean isPending() {
return getState() == StateValue.PENDING;
}
/**
* Equivalent to {@code getState() == StateValue.STARTED}.
*
* When a pending Task's state changes to {@code StateValue.STARTED}
* a PropertyChangeEvent for the "started" property is fired. Similarly
* when a started Task's state changes to {@code StateValue.DONE}, a
* "done" PropertyChangeEvent is fired.
* @return true if the state is {@code STARTED}
*/
public final boolean isStarted() {
return getState() == StateValue.STARTED;
}
/**
* {@inheritDoc}
*
* This method fires the TaskListeners' {@link TaskListener#process process}
* method. If you override {@code process} and do not call
* {@code super.process(values)}, then the TaskListeners will not run.
*
* @param values @{inheritDoc}
*/
@Override
protected void process(List
* This method runs on the EDT. It does nothing by default.
*
* @see #done
*/
protected void cancelled() {
}
/**
* Called when this Task has successfully completed, i.e. when
* its {@code get} method returns a value. Tasks that compute
* a value should override this method.
*
*
* This method runs on the EDT. It does nothing by default.
*
* @param result the value returned by the {@code get} method
* @see #done
* @see #get
* @see #failed
*/
protected void succeeded(T result) {
}
/**
* Called if the Task's Thread is interrupted but not
* explicitly cancelled.
*
* This method runs on the EDT. It does nothing by default.
*
* @param e the {@code InterruptedException} thrown by {@code get}
* @see #cancel
* @see #done
* @see #get
*/
protected void interrupted(InterruptedException e) {
}
/**
* Called when an execution of this Task fails and an
* {@code ExecutionExecption} is thrown by {@code get}.
*
* This method runs on the EDT. It Logs an error message by default.
*
* @param cause the {@link Throwable#getCause cause} of the {@code ExecutionException}
* @see #done
* @see #get
* @see #failed
*/
protected void failed(Throwable cause) {
String msg = String.format("%s failed: %s", this, cause);
logger.log(Level.SEVERE, msg, cause);
}
/**
* Called unconditionally (in a {@code finally} clause) after one
* of the completion methods, {@code succeeded}, {@code failed},
* {@code cancelled}, or {@code interrupted}, runs. Subclasses
* can override this method to cleanup before the {@code done}
* method returns.
*
* This method runs on the EDT. It does nothing by default.
*
* @see #done
* @see #get
* @see #failed
*/
protected void finished() {
}
/**
* Adds a {@code TaskListener} to this Task. The listener will
* be notified when the Task's state changes to {@code STARTED},
* each time the {@code process} method is called, and when the
* Task's state changes to {@code DONE}. All of the listener
* methods will run on the event dispatching thread.
*
* @param listener the {@code TaskListener} to be added
* @see #removeTaskListener
*/
public void addTaskListener(TaskListener
* This is a bound property.
*
* @return this task's InputBlocker
* @see #setInputBlocker
*/
public final InputBlocker getInputBlocker() {
return inputBlocker;
}
/**
* Set this task's InputBlocker. The InputBlocker defines
* to what extent the GUI should be blocked while the Task
* is executed by a TaskService. It is not used by the Task
* directly, it's used by the TaskService that executes the Task.
*
* This property may only be set before the Task is
* {@link TaskService#execute submitted} to a TaskService for
* execution. If it's called afterwards, an IllegalStateException
* is thrown.
*
* This is a bound property.
*
* @param inputBlocker
* @see #getInputBlocker
*/
public final void setInputBlocker(InputBlocker inputBlocker) {
if (getTaskService() != null) {
throw new IllegalStateException("task already being executed");
}
InputBlocker oldInputBlocker, newInputBlocker;
synchronized (this) {
oldInputBlocker = this.inputBlocker;
this.inputBlocker = inputBlocker;
newInputBlocker = this.inputBlocker;
}
firePropertyChange(PROP_INPUTBLOCKER, oldInputBlocker, newInputBlocker);
}
/**
* Specifies to what extent input to the Application's GUI should
* be blocked while this Task is being executed and provides
* a pair of methods, {@code block} and {@code unblock} that
* do the work of blocking the GUI. For the sake of input blocking,
* a Task begins executing when it's {@link TaskService#execute submitted}
* to a {@code TaskService}, and it finishes executing after
* the Task's completion methods have been called.
*
* The InputBlocker's {@link Task.BlockingScope
* BlockingScope} and the blocking {@code target} object define
* what part of the GUI's input will be blocked:
*
* Input blocking begins when the {@code block} method is called and
* ends when {@code unblock} is called. Each method is only
* called once, typically by the {@code TaskService}.
*
* @see Task#getInputBlocker
* @see Task#setInputBlocker
* @see TaskService
* @see Action
*/
public static abstract class InputBlocker extends AbstractBean {
private final Task task;
private final BlockingScope scope;
private final Object target;
private final ApplicationAction action;
/**
* Construct an InputBlocker with four immutable properties. If
* the Task is null or if the Task has already been
* executed by a TaskService, then an exception is thrown.
* If scope is {@code BlockingScope.ACTION} then target must be
* a {@link javax.swing.Action Action}. If scope is
* {@code BlockingScope.WINDOW} or {@code BlockingScope.COMPONENT}
* then target must be a Component.
*
* @param task block input while this Task is executing
* @param scope how much of the GUI will be blocked
* @param target the GUI element that will be blocked
* @param action the {@code @Action} that triggered running the task, or null
* @see TaskService#execute
*/
public InputBlocker(Task task, BlockingScope scope, Object target, ApplicationAction action) {
if (task == null) {
throw new IllegalArgumentException("null task");
}
if (task.getTaskService() != null) {
throw new IllegalStateException("task already being executed");
}
switch (scope) {
case ACTION:
if (!(target instanceof javax.swing.Action)) {
throw new IllegalArgumentException("target not an Action");
}
break;
case COMPONENT:
case WINDOW:
if (!(target instanceof Component)) {
throw new IllegalArgumentException("target not a Component");
}
break;
}
this.task = task;
this.scope = scope;
this.target = target;
this.action = action;
}
/**
* Construct an InputBlocker. If {@code target} is an
* {@code ApplicationAction}, it becomes the InputBlocker's
* {@code action}. If the Task is null or if the Task has already been
* executed by a TaskService, then an exception is thrown.
*
* @param task block input while this Task is executing
* @param scope how much of the GUI will be blocked
* @param target the GUI element that will be blocked
* @see TaskService#execute
*/
public InputBlocker(Task task, BlockingScope scope, Object target) {
this(task, scope, target, (target instanceof ApplicationAction) ? (ApplicationAction) target : null);
}
/**
* The {@code block} method will block input while this Task
* is being executed by a TaskService.
*
* @return the value of the read-only Task property
* @see #block
* @see #unblock
*/
public final Task getTask() {
return task;
}
/**
* Defines the extent to which the GUI is blocked while
* the task is being executed.
*
* @return the value of the read-only blockingScope property
* @see #block
* @see #unblock
*/
public final BlockingScope getScope() {
return scope;
}
/**
* Specifies the GUI element that will be blocked while
* the task is being executed.
*
* This property may be null.
*
* @return the value of the read-only target property
* @see #getScope
* @see #block
* @see #unblock
*/
public final Object getTarget() {
return target;
}
/**
* The ApplicationAction ({@code @Action}) that caused
* the task to be executed. The DefaultInputBlocker uses
* the action's {@code name} and {@code resourceMap} to
* configure its blocking dialog if {@code scope} is
* {@code BlockingScope.WINDOW}.
*
* This property may be null.
*
* @return the value of the read-only action property
* @see #getScope
* @see #block
* @see #unblock
* @see ApplicationAction#getName
* @see ApplicationAction#getResourceMap
*/
public final ApplicationAction getAction() {
return action;
}
/**
* Block input to the GUI per the {@code scope} and {@code target}
* properties. This method will only be called once.
*
* @see #unblock
* @see TaskService#execute
*/
protected abstract void block();
/**
* Unblock input to the GUI by undoing whatever the {@code block}
* method did. This method will only be called once.
*
* @see #block
* @see TaskService#execute
*/
protected abstract void unblock();
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/TaskEvent.java 0000664 0000000 0000000 00000001627 11516403062 0024422 0 ustar 00root root 0000000 0000000 package org.jdesktop.application;
import java.util.EventObject;
/**
* An encapsulation of the value produced one of the {@code Task} execution
* methods: {@code doInBackground()}, {@code process}, {@code done}. The source
* of a {@code TaskEvent} is the {@code Task} that produced the value.
*
* @param
* The Task class runs all TaskListener methods on the event dispatching
* thread and the source of all TaskEvents is the Task object.
* @param
* The value of {@link #getTasks getTasks()} is a list of all of the
* {@code Tasks} whose state is not {@link
* Task#isDone DONE} for all of the
* ApplicationContext's {@code TaskServices}. In other words: all of
* the ApplicationContext's background tasks that haven't finished
* executing. Each time a new TaskService Task is executed it's added
* to the list; when the Task finishes it's removed. Each time the
* list changes {@code PropertyChangeListeners} are fired.
* Applications that wish to create a detailed visualization of all
* Tasks should monitor the TaskMonitor {@code "tasks"} property.
*
*
* Users are often only interested in the status of a single
* foreground task, typically the one associated with GUI
* element they're working with, or with the most recent command
* they've issued. The TaskMonitor's PropertyChangeListener is
* notified each time a property of the {@link #setForegroundTask
* foregroundTask} changes. Additionally the TaskMonitor fires
* synthetic PropertyChangeEvents for properties named "pending",
* "started", and "done" when the corresponding Task {@code state}
* property changes occur.
*
*
* TaskMonitor manages a queue of new Tasks. The
* foregroundTask is automatically set to the first new Task, and when
* that Task finishes, the next Task in the queue, and so on.
* Applications can set the foregroundTask explicitly, to better
* reflect what the user is doing. For example, a tabbed browsing GUI
* that launched one Task per tab might set the foreground Task each
* time the user selected a tab. To prevent the foregroundTask
* property from (ever) being reset automatically, one must set {@link
* #setAutoUpdateForegroundTask autoUpdateForegroundTask} to false.
*
*
* This class is not thread-safe. All of its methods must be called
* on the event dispatching thread (EDT) and all of its listeners will
* run on the EDT.
*
*
* @author Hans Muller (Hans.Muller@Sun.COM)
* @see ApplicationContext#getTaskServices
* @see TaskService#getTasks
* @see TaskService#execute
*/
public class TaskMonitor extends AbstractBean {
public static final String PROP_FOREGROUND_TASK = "foregroundTask";
private final PropertyChangeListener applicationPCL;
private final PropertyChangeListener taskServicePCL;
private final PropertyChangeListener taskPCL;
private final LinkedList
* This property is true by default.
*
* @return true if the foregroundTask should be set automatically.
* @see #setAutoUpdateForegroundTask
* @see #setForegroundTask
*/
public boolean getAutoUpdateForegroundTask() {
return autoUpdateForegroundTask;
}
/**
* True if the {@code foregroundTask} property should be automatically
* reset to the oldest Task in the queue when it finishes running. An
* application that wants explicit control over the Task being monitored
* can set this property to false.
*
* This property is true by default.
*
* @param autoUpdateForegroundTask true if the foregroundTask should be set automatically
* @see #getAutoUpdateForegroundTask
*/
public void setAutoUpdateForegroundTask(boolean autoUpdateForegroundTask) {
boolean oldValue = this.autoUpdateForegroundTask;
this.autoUpdateForegroundTask = autoUpdateForegroundTask;
firePropertyChange("autoUpdateForegroundTask", oldValue, this.autoUpdateForegroundTask);
}
private List
* Each time the list of Tasks changes, a PropertyChangeEvent for the
* property named "tasks" is fired. Applications that want to monitor all
* background Tasks should monitor the tasks property.
*
* @return a list of all Tasks that aren't {@code DONE}
*/
public List
* Methods descriptions are copied from {@link ExecutorService}
*
*/
public class TaskService extends AbstractBean {
private final String name;
private final ExecutorService executorService;
private final List There are no guarantees beyond best-effort attempts to stop
* processing actively executing tasks. For example, typical
* implementations will cancel via {@link Thread#interrupt}, so any
* task that fails to respond to interrupts may never terminate.
*
* @return list of tasks that never commenced execution
* @throws SecurityException if a security manager exists and
* shutting down this ExecutorService may manipulate
* threads that the caller is not permitted to modify
* because it does not hold {@link
* java.lang.RuntimePermission}("modifyThread"),
* or the security manager's checkAccess method
* denies access.
*/
public final List
* To show or hide a View you call the corresponding Application methods. Here's a simple
* example:
*
* The advantage of Views over just configuring a JFrame or JApplet
* directly, is that a View is more easily moved to an alternative
* top level container, like a docking framework.
*
* @see JRootPane
* @see Application#show(View)
* @see Application#hide(View)
*/
public class View extends AbstractBean {
private static final Logger logger = Logger.getLogger(View.class.getName());
private final Application application;
private ResourceMap resourceMap = null;
private JRootPane rootPane = null;
private JComponent component = null;
private JMenuBar menuBar = null;
private List
* This is a bound property. The default value is null.
*
* @param component The {@code component} for this View
* @see #getComponent
*/
public void setComponent(JComponent component) {
JComponent oldValue = this.component;
this.component = component;
replaceContentPaneChild(oldValue, this.component, BorderLayout.CENTER);
firePropertyChange("component", oldValue, this.component);
}
/**
* Returns the main {@link JMenuBar} for this View.
*
* @return The {@code menuBar} for this View
* @see #setMenuBar
*/
public JMenuBar getMenuBar() {
return menuBar;
}
/**
* Sets the menu bar for this View.
*
* This is a bound property. The default value is null.
*
* @param menuBar The {@code menuBar} for this View
* @see #getMenuBar
*/
public void setMenuBar(JMenuBar menuBar) {
JMenuBar oldValue = getMenuBar();
this.menuBar = menuBar;
getRootPane().setJMenuBar(menuBar);
firePropertyChange("menuBar", oldValue, menuBar);
}
/**
* Returns the list of tool bars for this View
*
* @return The list of tool bars
*/
public List
* This is a bound property. The default value is an empty list.
*
* @param toolBars
* @see #setToolBar(JToolBar)
* @see #getToolBars()
*/
public void setToolBars(List
* This is a bound property.
*
* @param toolBar The {@link JToolBar} for this view. If {@code null} resets the tool bar.
* @see #getToolBar()
* @see #setToolBars(List)
* @see #getToolBars()
*/
public final void setToolBar(JToolBar toolBar) {
JToolBar oldValue = getToolBar();
List
* This class defines how the session state for {@code JSplitPanes}
* is {@link WindowProperty#getSessionState saved} and
* and {@link WindowProperty#setSessionState restored} in
* terms of a property called {@code sessionState}. The
* JSplitPane's {@code dividerLocation} is saved and restored
* if its {@code orientation} hasn't changed.
*
* {@code SplitPaneProperty} is registered for {@code
* JSplitPane.class} by default, so this class applies to
* JSplitPane and any subclass of JSplitPane. One can
* override the default with the {@link org.jdesktop.application.SessionStorage#putProperty putProperty}
* method.
*
* @see SplitPaneState
* @see org.jdesktop.application.SessionStorage#save
* @see org.jdesktop.application.SessionStorage#restore
*/
public class SplitPaneProperty implements PropertySupport {
private void checkComponent(Component component) {
if (component == null) {
throw new IllegalArgumentException("null component");
}
if (!(component instanceof JSplitPane)) {
throw new IllegalArgumentException("invalid component");
}
}
/**
* Returns a {@link SplitPaneState SplitPaneState} object
* for {@code JSplitPane c}. If the split pane's
* {@code dividerLocation} is -1, indicating that either
* the divider hasn't been moved, or it's been reset,
* then return null.
*
* Throws an {@code IllegalArgumentException} if {@code Component c}
* isn't a non-null {@code JSplitPane}.
*
* @param c the {@code JSplitPane} whose dividerLocation will
* recoreded in a {@code SplitPaneState} object.
* @return the {@code SplitPaneState} object
* @see #setSessionState
* @see SplitPaneState
*/
@Override
public Object getSessionState(Component c) {
checkComponent(c);
JSplitPane p = (JSplitPane) c;
return new SplitPaneState(p.getUI().getDividerLocation(p), p.getOrientation());
}
/**
* Restore the {@code JSplitPane's} {@code dividerLocation}
* property if its {@link JSplitPane#getOrientation orientation}
* has not changed.
*
* Throws an {@code IllegalArgumentException} if {@code c} is
* not a {@code JSplitPane} or if {@code state} is non-null
* but not an instance of {@link SplitPaneState}.
*
* @param c the JSplitPane whose state is to be restored
* @param state the {@code SplitPaneState} to be restored
* @see #getSessionState
* @see SplitPaneState
*/
@Override
public void setSessionState(Component c, Object state) {
checkComponent(c);
if (state == null) return;
if (state instanceof SplitPaneState) {
JSplitPane p = (JSplitPane) c;
SplitPaneState sps = (SplitPaneState) state;
if (p.getOrientation() == sps.getOrientation()) {
p.setDividerLocation(sps.getDividerLocation());
}
} else {
throw new IllegalArgumentException("invalid state");
}
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/session/SplitPaneState.java 0000664 0000000 0000000 00000003530 11516403062 0027074 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009 Illya Yalovyy
* Use is subject to license terms.
*/
package org.jdesktop.application.session;
import javax.swing.JSplitPane;
/**
* This Java Bean records the {@code dividerLocation} and {@code
* orientation} properties of a {@code JSplitPane}. A {@code
* SplitPaneState} object created by {@link
* SplitPaneProperty#getSessionState} and used to restore the
* selected tab by {@link SplitPaneProperty#setSessionState}.
*
* @see SplitPaneProperty
* @see org.jdesktop.application.SessionStorage#save
* @see org.jdesktop.application.SessionStorage#restore
*/
public class SplitPaneState {
private int dividerLocation = -1;
private int orientation = JSplitPane.HORIZONTAL_SPLIT;
private void checkOrientation(int orientation) {
if ((orientation != JSplitPane.HORIZONTAL_SPLIT) && (orientation != JSplitPane.VERTICAL_SPLIT)) {
throw new IllegalArgumentException("invalid orientation");
}
}
public SplitPaneState() {
super();
}
public SplitPaneState(int dividerLocation, int orientation) {
super();
checkOrientation(orientation);
if (dividerLocation < -1) {
throw new IllegalArgumentException("invalid dividerLocation");
}
this.dividerLocation = dividerLocation;
this.orientation = orientation;
}
public int getDividerLocation() {
return dividerLocation;
}
public void setDividerLocation(int dividerLocation) {
if (dividerLocation < -1) {
throw new IllegalArgumentException("invalid dividerLocation");
}
this.dividerLocation = dividerLocation;
}
public int getOrientation() {
return orientation;
}
public void setOrientation(int orientation) {
checkOrientation(orientation);
this.orientation = orientation;
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/session/TabbedPaneProperty.java 0000664 0000000 0000000 00000006144 11516403062 0027732 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009 Illya Yalovyy
* Use is subject to license terms.
*/
package org.jdesktop.application.session;
import java.awt.Component;
import javax.swing.JTabbedPane;
/**
* A {@code sessionState} property for JTabbedPane.
*
* This class defines how the session state for {@code JTabbedPanes}
* is {@link WindowProperty#getSessionState saved} and
* and {@link WindowProperty#setSessionState restored} in
* terms of a property called {@code sessionState}. The
* JTabbedPane's {@code selectedIndex} is saved and restored
* if the number of tabs ({@code tabCount}) hasn't changed.
*
* {@code TabbedPaneProperty} is registered for {@code
* JTabbedPane.class} by default, so this class applies to
* JTabbedPane and any subclass of JTabbedPane. One can
* override the default with the {@link org.jdesktop.application.SessionStorage#putProperty putProperty}
* method.
*
* @see TabbedPaneState
* @see org.jdesktop.application.SessionStorage#save
* @see org.jdesktop.application.SessionStorage#restore
*/
public class TabbedPaneProperty implements PropertySupport {
private void checkComponent(Component component) {
if (component == null) {
throw new IllegalArgumentException("null component");
}
if (!(component instanceof JTabbedPane)) {
throw new IllegalArgumentException("invalid component");
}
}
/**
* Returns a {@link TabbedPaneState TabbedPaneState} object
* for {@code JTabbedPane c}.
*
* Throws an {@code IllegalArgumentException} if {@code Component c}
* isn't a non-null {@code JTabbedPane}.
*
* @param c the {@code JTabbedPane} whose selectedIndex will
* recoreded in a {@code TabbedPaneState} object.
* @return the {@code TabbedPaneState} object
* @see #setSessionState
* @see TabbedPaneState
*/
@Override
public Object getSessionState(Component c) {
checkComponent(c);
JTabbedPane p = (JTabbedPane) c;
return new TabbedPaneState(p.getSelectedIndex(), p.getTabCount());
}
/**
* Restore the {@code JTabbedPane's} {@code selectedIndex}
* property if the number of {@link JTabbedPane#getTabCount tabs}
* has not changed.
*
* Throws an {@code IllegalArgumentException} if {@code c} is
* not a {@code JTabbedPane} or if {@code state} is non-null
* but not an instance of {@link TabbedPaneState}.
*
* @param c the JTabbedPane whose state is to be restored
* @param state the {@code TabbedPaneState} to be restored
* @see #getSessionState
* @see TabbedPaneState
*/
@Override
public void setSessionState(Component c, Object state) {
checkComponent(c);
if (state == null) return;
if (state instanceof TabbedPaneState){
JTabbedPane p = (JTabbedPane) c;
TabbedPaneState tps = (TabbedPaneState) state;
if (p.getTabCount() == tps.getTabCount()) {
p.setSelectedIndex(tps.getSelectedIndex());
}
} else {
throw new IllegalArgumentException("invalid state");
}
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/session/TabbedPaneState.java 0000664 0000000 0000000 00000003277 11516403062 0027172 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009 Illya Yalovyy
* Use is subject to license terms.
*/
package org.jdesktop.application.session;
/**
* This Java Bean record the {@code selectedIndex} and {@code
* tabCount} properties of a {@code JTabbedPane}. A {@code
* TabbedPaneState} object created by {@link
* TabbedPaneProperty#getSessionState} and used to restore the
* selected tab by {@link TabbedPaneProperty#setSessionState}.
*
* @see TabbedPaneProperty
* @see org.jdesktop.application.SessionStorage#save
* @see org.jdesktop.application.SessionStorage#restore
*/
public class TabbedPaneState {
private int selectedIndex;
private int tabCount;
public TabbedPaneState() {
super();
selectedIndex = -1;
tabCount = 0;
}
public TabbedPaneState(int selectedIndex, int tabCount) {
super();
if (tabCount < 0) {
throw new IllegalArgumentException("invalid tabCount");
}
if ((selectedIndex < -1) || (selectedIndex > tabCount)) {
throw new IllegalArgumentException("invalid selectedIndex");
}
this.selectedIndex = selectedIndex;
this.tabCount = tabCount;
}
public int getSelectedIndex() {
return selectedIndex;
}
public void setSelectedIndex(int selectedIndex) {
if (selectedIndex < -1) {
throw new IllegalArgumentException("invalid selectedIndex");
}
this.selectedIndex = selectedIndex;
}
public int getTabCount() {
return tabCount;
}
public void setTabCount(int tabCount) {
if (tabCount < 0) {
throw new IllegalArgumentException("invalid tabCount");
}
this.tabCount = tabCount;
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/session/TableProperty.java 0000664 0000000 0000000 00000007433 11516403062 0026776 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009 Illya Yalovyy
* Use is subject to license terms.
*/
package org.jdesktop.application.session;
import java.awt.Component;
import javax.swing.JTable;
import javax.swing.table.TableColumn;
/**
* A {@code sessionState} property for JTable
*
* This class defines how the session state for {@code JTables}
* is {@link WindowProperty#getSessionState saved} and
* and {@link WindowProperty#setSessionState restored} in
* terms of a property called {@code sessionState}.
* We save and restore the width of each resizable
* {@code TableColumn}, if the number of columns haven't
* changed.
*
* {@code TableProperty} is registered for {@code
* JTable.class} by default, so this class applies to
* JTable and any subclass of JTable. One can
* override the default with the {@link org.jdesktop.application.SessionStorage#putProperty putProperty}
* method.
*
* @see TableState
* @see org.jdesktop.application.SessionStorage#save
* @see org.jdesktop.application.SessionStorage#restore
*/
public class TableProperty implements PropertySupport {
private void checkComponent(Component component) {
if (component == null) {
throw new IllegalArgumentException("null component");
}
if (!(component instanceof JTable)) {
throw new IllegalArgumentException("invalid component");
}
}
/**
* Returns a {@link TableState TableState} object
* for {@code JTable c} or null, if none of the JTable's
* columns are {@link TableColumn#getResizable resizable}.
* A width of -1 is used to mark {@code TableColumns}
* that are not resizable.
*
* Throws an {@code IllegalArgumentException} if {@code Component c}
* isn't a non-null {@code JTable}.
*
* @param c the {@code JTable} whose columnWidths will be
* saved in a {@code TableState} object.
* @return the {@code TableState} object or null
* @see #setSessionState
* @see TableState
*/
@Override
public Object getSessionState(Component c) {
checkComponent(c);
JTable table = (JTable) c;
int[] columnWidths = new int[table.getColumnCount()];
boolean resizableColumnExists = false;
for (int i = 0; i < columnWidths.length; i++) {
TableColumn tc = table.getColumnModel().getColumn(i);
columnWidths[i] = (tc.getResizable()) ? tc.getWidth() : -1;
if (tc.getResizable()) {
resizableColumnExists = true;
}
}
return (resizableColumnExists) ? new TableState(columnWidths) : null;
}
/**
* Restore the width of each resizable {@code TableColumn}, if
* the number of columns haven't changed.
*
* Throws an {@code IllegalArgumentException} if {@code c} is
* not a {@code JTable} or if {@code state} is not an instance
* of {@link TableState}.
*
* @param c the JTable whose column widths are to be restored
* @param state the {@code TableState} to be restored
* @see #getSessionState
* @see TableState
*/
@Override
public void setSessionState(Component c, Object state) {
checkComponent(c);
if (!(state instanceof TableState)) {
throw new IllegalArgumentException("invalid state");
}
JTable table = (JTable) c;
int[] columnWidths = ((TableState) state).getColumnWidths();
if (table.getColumnCount() == columnWidths.length) {
for (int i = 0; i < columnWidths.length; i++) {
if (columnWidths[i] != -1) {
TableColumn tc = table.getColumnModel().getColumn(i);
if (tc.getResizable()) {
tc.setPreferredWidth(columnWidths[i]);
}
}
}
}
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/session/TableState.java 0000664 0000000 0000000 00000002311 11516403062 0026220 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009 Illya Yalovyy
* Use is subject to license terms.
*/
package org.jdesktop.application.session;
/**
* This Java Bean records the {@code columnWidths} for all
* of the columns in a JTable. A width of -1 is used to
* mark {@code TableColumns} that are not resizable.
*
* @see TableProperty
* @see org.jdesktop.application.SessionStorage#save
* @see org.jdesktop.application.SessionStorage#restore
*/
public class TableState {
private int[] columnWidths = new int[0];
private int[] copyColumnWidths(int[] columnWidths) {
if (columnWidths == null) {
throw new IllegalArgumentException("invalid columnWidths");
}
int[] copy = new int[columnWidths.length];
System.arraycopy(columnWidths, 0, copy, 0, columnWidths.length);
return copy;
}
public TableState() {
super();
}
public TableState(int[] columnWidths) {
super();
this.columnWidths = copyColumnWidths(columnWidths);
}
public int[] getColumnWidths() {
return copyColumnWidths(columnWidths);
}
public void setColumnWidths(int[] columnWidths) {
this.columnWidths = copyColumnWidths(columnWidths);
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/session/WindowProperty.java 0000664 0000000 0000000 00000012550 11516403062 0027212 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009 Illya Yalovyy
* Use is subject to license terms.
*/
package org.jdesktop.application.session;
import java.awt.Component;
import java.awt.Frame;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsEnvironment;
import java.awt.Rectangle;
import java.awt.Window;
import javax.swing.JFrame;
import org.jdesktop.application.utils.SwingHelper;
import static org.jdesktop.application.utils.SwingHelper.isResizable;
import static org.jdesktop.application.utils.SwingHelper.computeVirtualGraphicsBounds;
/**
* A {@code sessionState} property for Window.
*
* This class defines how the session state for {@code Windows}
* is {@link WindowProperty#getSessionState saved} and
* and {@link WindowProperty#setSessionState restored} in
* terms of a property called {@code sessionState}. The
* Window's {@code bounds Rectangle} is saved and restored
* if the dimensions of the Window's screen have not changed.
*
* {@code WindowProperty} is registered for {@code Window.class} by
* default, so this class applies to the AWT {@code Window},
* {@code Dialog}, and {@code Frame} class, as well as their
* Swing counterparts: {@code JWindow}, {@code JDialog}, and
* {@code JFrame}.
*
* @see org.jdesktop.application.SessionStorage#save
* @see org.jdesktop.application.SessionStorage#restore
* @see WindowState
*/
public class WindowProperty implements PropertySupport {
private void checkComponent(Component component) {
if (component == null) {
throw new IllegalArgumentException("null component");
}
if (!(component instanceof Window)) {
throw new IllegalArgumentException("invalid component");
}
}
private int getScreenCount() {
return GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices().length;
}
/**
* Returns a {@link WindowState WindowState} object
* for {@code Window c}.
*
* Throws an {@code IllegalArgumentException} if {@code Component c}
* isn't a non-null {@code Window}.
*
* @param c the {@code Window} whose bounds will be stored
* in a {@code WindowState} object.
* @return the {@code WindowState} object
* @see #setSessionState
* @see WindowState
*/
@Override
public Object getSessionState(Component c) {
checkComponent(c);
int frameState = Frame.NORMAL;
if (c instanceof Frame) {
frameState = ((Frame) c).getExtendedState();
}
GraphicsConfiguration gc = c.getGraphicsConfiguration();
Rectangle gcBounds = (gc == null) ? null : gc.getBounds();
Rectangle frameBounds = c.getBounds();
/* If this is a JFrame created by FrameView and it's been maximized,
* retrieve the frame's normal (not maximized) bounds. More info:
* see FrameStateListener#windowStateChanged in FrameView.
*/
if ((c instanceof JFrame) && (0 != (frameState & Frame.MAXIMIZED_BOTH))) {
frameBounds = SwingHelper.getWindowNormalBounds((JFrame)c);
}
if (frameBounds.isEmpty()) return null;
return new WindowState(frameBounds, gcBounds, getScreenCount(), frameState);
}
/**
* Restore the {@code Window's} bounds if the dimensions of its
* screen ({@code GraphicsConfiguration}) haven't changed, the
* number of screens hasn't changed, and the
* {@link Window#isLocationByPlatform isLocationByPlatform}
* property, which indicates that native Window manager should
* pick the Window's location, is false. More precisely:
*
* If {@code state} is non-null, and Window {@code c's}
* {@code GraphicsConfiguration}
* {@link GraphicsConfiguration#getBounds bounds} matches
* the {@link WindowState#getGraphicsConfigurationBounds WindowState's value},
* and Window {@code c's}
* {@link Window#isLocationByPlatform isLocationByPlatform}
* property is false, then set the Window's to the
* {@link WindowState#getBounds saved value}.
*
* Throws an {@code IllegalArgumentException} if {@code c} is
* not a {@code Window} or if {@code state} is non-null
* but not an instance of {@link WindowState}.
*
* @param c the Window whose state is to be restored
* @param state the {@code WindowState} to be restored
* @see #getSessionState
* @see WindowState
*/
@Override
public void setSessionState(Component c, Object state) {
checkComponent(c);
if ((state != null) && !(state instanceof WindowState)) {
throw new IllegalArgumentException("invalid state");
}
Window w = (Window) c;
WindowState windowState = (WindowState) state;
SwingHelper.putWindowNormalBounds(w, windowState.getBounds());
if (!w.isLocationByPlatform() && (state != null)) {
Rectangle gcBounds0 = windowState.getGraphicsConfigurationBounds();
if (gcBounds0 != null && isResizable(w)) {
if (computeVirtualGraphicsBounds().contains(gcBounds0.getLocation())) {
w.setBounds(windowState.getBounds());
} else {
w.setSize(windowState.getBounds().getSize());
}
}
if (w instanceof Frame) {
((Frame) w).setExtendedState(windowState.getFrameState());
}
}
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/session/WindowState.java 0000664 0000000 0000000 00000004347 11516403062 0026453 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2009 Illya Yalovyy
* Use is subject to license terms.
*/
package org.jdesktop.application.session;
import java.awt.Frame;
import java.awt.Rectangle;
/**
* This Java Bean defines the {@code Window} state preserved across
* sessions: the Window's {@code bounds}, and the bounds of the
* Window's {@code GraphicsConfiguration}, i.e. the bounds of the
* screen that the Window appears on. If the Window is actually a
* Frame, we also store its extendedState. {@code WindowState} objects
* are stored and restored by the {@link WindowProperty WindowProperty}
* class.
*
* @see WindowProperty
* @see org.jdesktop.application.SessionStorage#save
* @see org.jdesktop.application.SessionStorage#restore
*/
public class WindowState {
private final Rectangle bounds;
private Rectangle gcBounds = null;
private int screenCount;
private int frameState = Frame.NORMAL;
public WindowState() {
super();
bounds = new Rectangle();
}
public WindowState(Rectangle bounds, Rectangle gcBounds, int screenCount, int frameState) {
super();
if (bounds == null) {
throw new IllegalArgumentException("null bounds");
}
if (screenCount < 1) {
throw new IllegalArgumentException("invalid screenCount");
}
this.bounds = bounds;
this.gcBounds = gcBounds;
// can be null
this.screenCount = screenCount;
this.frameState = frameState;
}
public Rectangle getBounds() {
return new Rectangle(bounds);
}
public void setBounds(Rectangle bounds) {
this.bounds.setBounds(bounds);
}
public int getScreenCount() {
return screenCount;
}
public void setScreenCount(int screenCount) {
this.screenCount = screenCount;
}
public int getFrameState() {
return frameState;
}
public void setFrameState(int frameState) {
this.frameState = frameState;
}
public Rectangle getGraphicsConfigurationBounds() {
return (gcBounds == null) ? null : new Rectangle(gcBounds);
}
public void setGraphicsConfigurationBounds(Rectangle gcBounds) {
this.gcBounds = (gcBounds == null) ? null : new Rectangle(gcBounds);
}
} bsaf-1.9/src/main/java/org/jdesktop/application/utils/ 0000775 0000000 0000000 00000000000 11516403062 0023005 5 ustar 00root root 0000000 0000000 bsaf-1.9/src/main/java/org/jdesktop/application/utils/AppHelper.java 0000664 0000000 0000000 00000002523 11516403062 0025532 0 ustar 00root root 0000000 0000000 package org.jdesktop.application.utils;
import java.security.AccessController;
import java.security.PrivilegedAction;
/**
* Class containing help methods on application level.
* @author Vity
*/
public final class AppHelper {
private static PlatformType activePlatformType = null;
private AppHelper() {
}
/**
* Determines a platform type the application is running on.
* @return current platform type
*/
public static PlatformType getPlatform() {
if (activePlatformType != null)
return activePlatformType;
activePlatformType = PlatformType.DEFAULT;
PrivilegedActionvoid or {@link Task}. If the return type
* is Task, the Task will be executed by the ApplicationAction's
* actionPerformed method.
*
* @see ApplicationAction
* @see ApplicationActionMap
* @see ApplicationContext
* @author Hans Muller (Hans.Muller@Sun.COM)
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Action {
/**
* The action name. The method name is used as an action name if not specified.
*/
String name() default "";
/**
* The parameter binds the enabled state of the @Action to the current value of a property.
*/
String enabledProperty() default "";
/**
* The parameter binds the selected state of the @Action to the current value of a property.
*/
String selectedProperty() default "";
/**
* The parameter indicates that the GUI should be blocked while the background task is running.
* @see Task
*/
BlockingScope block() default BlockingScope.NONE;
/**
* This annotation is not used yet
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
@interface Parameter {
String value() default "";
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/ActionManager.java 0000664 0000000 0000000 00000024342 11516403062 0025225 0 ustar 00root root 0000000 0000000
/*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.application;
import java.awt.KeyboardFocusManager;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.WeakHashMap;
import java.util.logging.Logger;
import javax.swing.ActionMap;
import javax.swing.JComponent;
/**
* The application's {@code ActionManager} provides read-only cached
* access to {@code ActionMaps} that contain one entry for each method
* marked with the {@code @Action} annotation in a class.
*
*
* @see ApplicationContext#getActionMap(Object)
* @see ApplicationActionMap
* @see ApplicationAction
* @author Hans Muller (Hans.Muller@Sun.COM)
*/
public class ActionManager extends AbstractBean {
private static final Logger logger = Logger.getLogger(ActionManager.class.getName());
private final ApplicationContext context;
private final WeakHashMap
* ApplicationContext.getInstance().getApplicationClass()
*
* The remainder of the chain contains one {@code ActionMap}
* for each superclass, up to {@code Application.class}. The
* {@code ActionMap.get()} method searches the entire chain, so
* logically, the {@code ActionMap} that this method returns contains
* all of the application-global actions.
*
* ApplicationContext ctx = Application.getInstance(MyApplication.class).getContext();
* MyActions myActions = new MyActions();
* myComponent.setAction(ac.getActionMap(myActions).get("myAction"));
*
*
*
* public class MyApplication extends Application {
* JFrame mainFrame = null;
* @Override protected void startup() {
* mainFrame = new JFrame("Hello World");
* mainFrame.add(new JLabel("Hello World"));
* mainFrame.addWindowListener(new MainFrameListener());
* mainFrame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
* mainFrame.pack();
* mainFrame.setVisible(true);
* }
* @Override protected void shutdown() {
* mainFrame.setVisible(false);
* }
* private class MainFrameListener extends WindowAdapter {
* public void windowClosing(WindowEvent e) {
* exit();
* }
* }
* public static void main(String[] args) {
* Application.launch(MyApplication.class, args);
* }
* }
*
*
* Application.name = A short name, typically just a few words
* Application.id = Suitable for Application specific identifiers, like file names
* Application.title = A title suitable for dialogs and frames
* Application.version = A version string that can be incorporated into messages
* Application.vendor = A proper name, like Sun Microsystems, Inc.
* Application.vendorId = suitable for Application-vendor specific identifiers, like file names.
* Application.homepage = A URL like http://www.javadesktop.org
* Application.description = One brief sentence
* Application.lookAndFeel = either system, default, or a LookAndFeel class name
*
*
*
*
* @see SingleFrameApplication
* @see ApplicationContext
* @see UIManager#setLookAndFeel
* @author Hans Muller (Hans.Muller@Sun.COM)
*/
@ProxyActions({"cut", "copy", "paste", "delete"})
public abstract class Application extends AbstractBean {
public static final String KEY_APPLICATION_TITLE = "Application.title";
public static final String KEY_APPLICATION_ICON = "Application.icon";
public static final String KEY_APPLICATION_VENDOR_ID = "Application.vendorId";
private static final Logger logger = Logger.getLogger(Application.class.getName());
private static Application application = null;
private final List
* public static void main(String[] args) {
* Application.launch(MyApplication.class, args);
* }
*
* The {@code applicationClass} constructor and {@code startup} methods
* run on the event dispatching thread.
*
* @param applicationClass the {@code Application} class to launch
* @param args {@code main} method arguments
* @see #shutdown
* @see ApplicationContext#getApplication
*/
public static synchronized
* class ConfirmExit implements Application.ExitListener {
* public boolean canExit(EventObject e) {
* Object source = (e != null) ? e.getSource() : null;
* Component owner = (source instanceof Component) ? (Component)source : null;
* int option = JOptionPane.showConfirmDialog(owner, "Really Exit?");
* return option == JOptionPane.YES_OPTION;
* }
* public void willExit(EventObejct e) {}
* }
* myApplication.addExitListener(new ConfirmExit());
*
* The {@code eventObject} argument may be null, e.g. if the exit
* call was triggered by non-GUI code, and {@code canExit}, {@code
* willExit} methods must guard against the possibility that the
* {@code eventObject} argument's {@code source} is not a {@code
* Component}.
*
* @param event the EventObject that triggered this call or null
* @see #addExitListener
* @see #removeExitListener
* @see #shutdown
* @see #end
*/
public void exit(final EventObject event) {
Runnable runnable = new Runnable() {
@Override
public void run() {
for (ExitListener listener : exitListeners) {
if (!listener.canExit(event)) {
return;
}
}
try {
for (ExitListener listener : exitListeners) {
try {
listener.willExit(event);
} catch (Exception e) {
logger.log(Level.WARNING, "ExitListener.willExit() failed", e);
}
}
shutdown();
} catch (Exception e) {
logger.log(Level.WARNING, "unexpected error in Application.shutdown()", e);
} finally {
end();
}
}
};
if (SwingUtilities.isEventDispatchThread()) {
runnable.run();
} else {
try {
SwingUtilities.invokeAndWait(runnable);
} catch (Exception ignore) { }
}
}
/**
* Called by {@link #exit exit} to terminate the application. Calls
* {@code Runtime.getRuntime().exit(0)}, which halts the JVM.
*
* @see #exit
*/
protected void end() {
Runtime.getRuntime().exit(0);
}
/**
* Gives the Application a chance to veto an attempt to exit/quit.
* An {@code ExitListener's} {@code canExit} method should return
* false if there are pending decisions that the user must make
* before the app exits. A typical {@code ExitListener} would
* prompt the user with a modal dialog.
*
* public class MyActions {
* @Action public void anAction() { } // an @Action named "anAction"
* }
* ApplicationContext ac = ApplicationContext.getInstance();
* ActionMap actionMap = ac.getActionMap(new MyActions());
* myButton.setAction(actionMap.get("anAction"));
*
*
*
* anAction.Action.text = Button/Menu/etc label text for anAction
* anAction.Action.shortDescription = Tooltip text for anAction
*
*
*
* public class MyActions {
* @Action(enabledProperty = "anActionEnabled")
* public void anAction() { }
* public boolean isAnActionEnabled() {
* // will fire PropertyChange when anActionEnabled changes
* return anActionEnabled;
* }
* }
*
* If the MyActions class supports PropertyChange events, then then
* ApplicationAction will track the state of the specified property
* ("anActionEnabled" in this case) with a PropertyChangeListener.
*
*
* public void actionPerformed(ActionEvent actionEvent) {
* javax.swing.Action proxy = getProxy();
* if (proxy != null) {
* actionEvent.setSource(getProxySource());
* proxy.actionPerformed(actionEvent);
* }
* // ....
* }
*
*
*
* @author Hans Muller (Hans.Muller@Sun.COM)
* @see ApplicationContext#getActionMap(Object)
* @see ResourceMap
*/
public class ApplicationAction extends AbstractAction {
private static final Logger logger = Logger.getLogger(ApplicationAction.class.getName());
private final ApplicationActionMap appAM;
private final ResourceMap resourceMap;
private final String actionName; // see getName()
private final Method actionMethod; // The @Action method
private final String enabledProperty; // names a bound appAM.getActionsClass() property
private final Method isEnabledMethod; // Method object for is/getEnabledProperty
private final Method setEnabledMethod; // Method object for setEnabledProperty
private final String selectedProperty; // names a bound appAM.getActionsClass() property
private final Method isSelectedMethod; // Method object for is/getSelectedProperty
private final Method setSelectedMethod; // Method object for setSelectedProperty
private final Task.BlockingScope block;
private javax.swing.Action proxy = null;
private Object proxySource = null;
private PropertyChangeListener proxyPCL = null;
/**
* Construct an ApplicationAction that implements an @Action.
*
*
* @Action void actionBaseName() { }
*
* actionBaseName.Action.shortDescription, as in:
*
* actionBaseName.Action.shortDescription = Do perform some action
*
*
*
* Action.icon
* Action.text
* Action.shortDescription
* Action.longDescription
* Action.smallIcon
* Action.largeIcon
* Action.command
* Action.accelerator
* Action.mnemonic
* Action.displayedMnemonicIndex
*
*
*
*
*
* @param appAM the ApplicationActionMap this action is being constructed for.
* @param resourceMap initial Action properties are loaded from this ResourceMap.
* @param baseName the name of the @Action
* @param actionMethod unless a proxy is specified, actionPerformed calls this method.
* @param enabledProperty name of the enabled property.
* @param selectedProperty name of the selected property.
* @param block how much of the GUI to block while this action executes.
*
* @see #getName
* @see ApplicationActionMap#getActionsClass
* @see ApplicationActionMap#getActionsObject
*/
public ApplicationAction(ApplicationActionMap appAM,
ResourceMap resourceMap,
String baseName,
Method actionMethod,
String enabledProperty,
String selectedProperty,
Task.BlockingScope block) {
if (appAM == null) {
throw new IllegalArgumentException("null appAM");
}
if (baseName == null) {
throw new IllegalArgumentException("null baseName");
}
this.appAM = appAM;
this.resourceMap = resourceMap;
this.actionName = baseName;
this.actionMethod = actionMethod;
this.enabledProperty = enabledProperty;
this.selectedProperty = selectedProperty;
this.block = block;
/* If enabledProperty is specified, lookup up the is/set methods and
* verify that the former exists.
*/
if (enabledProperty != null) {
setEnabledMethod = propertySetMethod(enabledProperty, boolean.class);
isEnabledMethod = propertyGetMethod(enabledProperty);
if (isEnabledMethod == null) {
throw newNoSuchPropertyException(enabledProperty);
}
} else {
this.isEnabledMethod = null;
this.setEnabledMethod = null;
}
/* If selectedProperty is specified, lookup up the is/set methods and
* verify that the former exists.
*/
if (selectedProperty != null) {
setSelectedMethod = propertySetMethod(selectedProperty, boolean.class);
isSelectedMethod = propertyGetMethod(selectedProperty);
if (isSelectedMethod == null) {
throw newNoSuchPropertyException(selectedProperty);
}
super.putValue(SELECTED_KEY, invokeBooleanMethod(appAM.getActionsObject(), isSelectedMethod));
} else {
this.isSelectedMethod = null;
this.setSelectedMethod = null;
}
if (resourceMap != null) {
initActionProperties(resourceMap, baseName);
}
}
/* Shorter convenience constructor used to create ProxyActions,
* see ApplicationActionMap.addProxyAction().
*/
ApplicationAction(ApplicationActionMap appAM, ResourceMap resourceMap, String actionName) {
this(appAM, resourceMap, actionName, null, null, null, Task.BlockingScope.NONE);
}
private IllegalArgumentException newNoSuchPropertyException(String propertyName) {
String actionsClassName = appAM.getActionsClass().getName();
String msg = String.format("no property named %s in %s", propertyName, actionsClassName);
return new IllegalArgumentException(msg);
}
/**
* The name of the {@code @Action} enabledProperty
* whose value is returned by {@link #isEnabled isEnabled},
* or null.
*
* @return the name of the enabledProperty or null.
* @see #isEnabled
*/
String getEnabledProperty() {
return enabledProperty;
}
/**
* The name of the {@code @Action} selectedProperty whose value is
* returned by {@link #isSelected isSelected}, or null.
*
* @return the name of the selectedProperty or null.
* @see #isSelected
*/
String getSelectedProperty() {
return selectedProperty;
}
/**
* Return the proxy for this action or null.
*
* @return the value of the proxy property.
* @see #setProxy
* @see #setProxySource
* @see #actionPerformed
*/
public javax.swing.Action getProxy() {
return proxy;
}
/**
* Set the proxy for this action. If the proxy is non-null then
* we delegate/track the following:
*
* Used to initialize the Action properties with keys
* Action.NAME, Action.MNEMONIC_KEY and
* Action.DISPLAYED_MNEMONIC_INDEX.
* If the resources's value contains an "&" or an "_" it's
* assumed to mark the following character as the mnemonic.
* If Action.mnemonic/Action.displayedMnemonic resources are
* also defined (an odd case), they'll override the mnemonic
* specfied with the Action.text marker character.
*
*
* Used to initialize both ACTION.SMALL_ICON,LARGE_ICON. If
* Action.smallIcon or Action.largeIcon resources are also defined
* they'll override the value defined for Action.icon.
*
*
* The corresponding javax.swing.Action constant is only defined in Java SE 6.
* We'll set the Action property in Java SE 5 too.
*
*
*
* @param proxy
* @see #setProxy
* @see #setProxySource
* @see #actionPerformed
*/
public void setProxy(javax.swing.Action proxy) {
javax.swing.Action oldProxy = this.proxy;
this.proxy = proxy;
if (oldProxy != null) {
oldProxy.removePropertyChangeListener(proxyPCL);
proxyPCL = null;
}
if (this.proxy != null) {
updateProxyProperties();
proxyPCL = new ProxyPCL();
proxy.addPropertyChangeListener(proxyPCL);
} else if (oldProxy != null) {
setEnabled(false);
setSelected(false);
}
firePropertyChange("proxy", oldProxy, this.proxy);
}
/**
* Return the value that becomes the ActionEvent source before
* the ActionEvent is passed along to the proxy Action.
*
* @return the value of the proxySource property.
* @see #getProxy
* @see #setProxySource
* @see ActionEvent#getSource
*/
public Object getProxySource() {
return proxySource;
}
/**
* Set the value that becomes the ActionEvent source before
* the ActionEvent is passed along to the proxy Action.
*
* @param source the ActionEvent source/
* @see #getProxy
* @see #getProxySource
* @see ActionEvent#setSource
*/
public void setProxySource(Object source) {
Object oldValue = this.proxySource;
this.proxySource = source;
firePropertyChange("proxySource", oldValue, this.proxySource);
}
private void maybePutDescriptionValue(String key, javax.swing.Action proxy) {
Object s = proxy.getValue(key);
if (s instanceof String) {
putValue(key, s);
}
}
private void updateProxyProperties() {
javax.swing.Action proxy = getProxy();
if (proxy != null) {
setEnabled(proxy.isEnabled());
Object s = proxy.getValue(SELECTED_KEY);
setSelected((s instanceof Boolean) && (Boolean) s);
maybePutDescriptionValue(javax.swing.Action.SHORT_DESCRIPTION, proxy);
maybePutDescriptionValue(javax.swing.Action.LONG_DESCRIPTION, proxy);
}
}
/* This PCL is added to the proxy action, i.e. getProxy(). We
* track the following properties of the proxy action we're bound to:
* enabled, selected, longDescription, shortDescription. We only
* mirror the description properties if they're non-null.
*/
private class ProxyPCL implements PropertyChangeListener {
public void propertyChange(PropertyChangeEvent e) {
String propertyName = e.getPropertyName();
if ((propertyName == null) ||
"enabled".equals(propertyName) ||
"selected".equals(propertyName) ||
javax.swing.Action.SHORT_DESCRIPTION.equals(propertyName) ||
javax.swing.Action.LONG_DESCRIPTION.equals(propertyName)) {
updateProxyProperties();
}
}
}
/* Init all of the javax.swing.Action properties for the @Action
* named actionName.
*/
private void initActionProperties(ResourceMap resourceMap, String baseName) {
boolean iconOrNameSpecified = false; // true if Action's icon/name properties set
// Action.text => Action.NAME,MNEMONIC_KEY,DISPLAYED_MNEMONIC_INDEX_KEY
String text = resourceMap.getString(baseName + ".Action.text");
if (text != null) {
MnemonicText.configure(this, text);
iconOrNameSpecified = true;
}
// Action.mnemonic => Action.MNEMONIC_KEY
Integer mnemonic = resourceMap.getKeyCode(baseName + ".Action.mnemonic");
if (mnemonic != null) {
putValue(javax.swing.Action.MNEMONIC_KEY, mnemonic);
}
// Action.mnemonic => Action.DISPLAYED_MNEMONIC_INDEX_KEY
Integer index = resourceMap.getInteger(baseName + ".Action.displayedMnemonicIndex");
if (index != null) {
putValue(DISPLAYED_MNEMONIC_INDEX_KEY, index);
}
// Action.accelerator => Action.ACCELERATOR_KEY
KeyStroke key = resourceMap.getKeyStroke(baseName + ".Action.accelerator");
if (key != null) {
putValue(javax.swing.Action.ACCELERATOR_KEY, key);
}
// Action.icon => Action.SMALL_ICON,LARGE_ICON_KEY
Icon icon = resourceMap.getIcon(baseName + ".Action.icon");
if (icon != null) {
putValue(javax.swing.Action.SMALL_ICON, icon);
putValue(LARGE_ICON_KEY, icon);
iconOrNameSpecified = true;
}
// Action.smallIcon => Action.SMALL_ICON
Icon smallIcon = resourceMap.getIcon(baseName + ".Action.smallIcon");
if (smallIcon != null) {
putValue(javax.swing.Action.SMALL_ICON, smallIcon);
iconOrNameSpecified = true;
}
// Action.largeIcon => Action.LARGE_ICON
Icon largeIcon = resourceMap.getIcon(baseName + ".Action.largeIcon");
if (largeIcon != null) {
putValue(LARGE_ICON_KEY, largeIcon);
iconOrNameSpecified = true;
}
// Action.shortDescription => Action.SHORT_DESCRIPTION
String shortDescription = resourceMap.getString(baseName +
".Action.shortDescription");
if (shortDescription != null && !shortDescription.isEmpty()) {
putValue(javax.swing.Action.SHORT_DESCRIPTION,
resourceMap.getString(baseName + ".Action.shortDescription"));
}
// Action.longDescription => Action.LONG_DESCRIPTION
putValue(javax.swing.Action.LONG_DESCRIPTION,
resourceMap.getString(baseName + ".Action.longDescription"));
// Action.command => Action.ACTION_COMMAND_KEY
putValue(javax.swing.Action.ACTION_COMMAND_KEY,
resourceMap.getString(baseName + ".Action.command"));
// If no visual was defined for this Action, i.e. no text
// and no icon, then we default Action.NAME
if (!iconOrNameSpecified) {
putValue(javax.swing.Action.NAME, actionName);
}
}
private String propertyMethodName(String prefix, String propertyName) {
return prefix + propertyName.substring(0, 1).toUpperCase(java.util.Locale.ENGLISH) + propertyName.substring(1);
}
private Method propertyGetMethod(String propertyName) {
String[] getMethodNames = {
propertyMethodName("is", propertyName),
propertyMethodName("get", propertyName)
};
Class actionsClass = appAM.getActionsClass();
for (String name : getMethodNames) {
try {
return actionsClass.getMethod(name);
} catch (NoSuchMethodException ignore) {
}
}
return null;
}
private Method propertySetMethod(String propertyName, Class type) {
Class actionsClass = appAM.getActionsClass();
try {
return actionsClass.getMethod(propertyMethodName("set", propertyName), type);
} catch (NoSuchMethodException ignore) {
return null;
}
}
/**
*
* The name of this Action. This string begins with the name
* the corresponding @Action method (unless the name
* @Action parameter was specified).
*
*
* Our actionPerformed method calls the delegate's after
* the ActionEvent source to be the value of getProxySource
*
*
* If the proxy's shortDescription, i.e. the value for key
* {@link javax.swing.Action#SHORT_DESCRIPTION SHORT_DESCRIPTION} is not null,
* then set this action's shortDescription. Most Swing components use
* the shortDescription to initialize their tooltip.
*
*
* If the proxy's longDescription, i.e. the value for key
* {@link javax.swing.Action#LONG_DESCRIPTION LONG_DESCRIPTION} is not null,
* then set this action's longDescription.
*
* myCloseButton.Action.text = Close
*
*
*
* @return the (read-only) value of the name property
*/
public String getName() {
return actionName;
}
/**
* The resourceMap for this Action.
*
* @return the (read-only) value of the resourceMap property
*/
public ResourceMap getResourceMap() {
return resourceMap;
}
/**
*
* Provides parameter values to @Action methods. By default, parameter
* values are selected based exclusively on their type:
*
*
*
*
*
* Parameter Type
* Parameter Value
*
*
* ActionEvent
* actionEvent
*
*
* javax.swing.Action
* this ApplicationAction object
*
*
* ActionMap
* the ActionMap that contains this Action
*
*
* ResourceMap
* the ResourceMap of the the ActionMap that contains this Action
*
*
* ApplicationContext
* the value of ApplicationContext.getInstance()
*
* @Action public void doAction(@Action.Parameter("myKey") String myParameter) {
* // The value of myParameter is computed by:
* // getActionArgument(String.class, "myKey", actionEvent)
* }
*
*
*
* public class HelloWorldActions {
* public @Action void Hello() { System.out.print("Hello "); }
* public @Action void World() { System.out.println("World"); }
* }
* // ...
* ApplicationActionMap appAM = new ApplicationActionMap(SimpleActions.class);
* ActionEvent e = new ActionEvent("no src", ActionEvent.ACTION_PERFORMED, "no cmd");
* appAM.get("Hello").actionPerformed(e);
* appAM.get("World").actionPerformed(e);
*
*
*
* return getResourceManager().getResourceMap(cls, cls);
*
*
* @param cls the class that defines the location of ResourceBundles
* @return a {@code ResourceMap} that contains resources loaded from
* {@code ResourceBundles} found in the resources subpackage of the
* specified class's package.
* @see ResourceManager#getResourceMap(Class)
*/
public final ResourceMap getResourceMap(Class cls) {
return getResourceManager().getResourceMap(cls, cls);
}
/**
* Returns a {@link ResourceMap#getParent chain} of two or more
* ResourceMaps. The first encapsulates the ResourceBundles
* defined for the all of the classes between {@code startClass}
* and {@code stopClass} inclusive. It's parent encapsulates the
* ResourceBundles defined for the entire application.
*
* return getResourceManager().getResourceMap(startClass, stopClass);
*
*
* @param startClass the first class whose ResourceBundles will be included
* @param stopClass the last class whose ResourceBundles will be included
* @return a {@code ResourceMap} that contains resources loaded from
* {@code ResourceBundles} found in the resources subpackage of the
* specified class's package.
* @see ResourceManager#getResourceMap(Class, Class)
*/
public final ResourceMap getResourceMap(Class startClass, Class stopClass) {
return getResourceManager().getResourceMap(startClass, stopClass);
}
/**
* Returns the {@link ResourceMap#getParent chain} of ResourceMaps
* that's shared by the entire application, beginning with the one
* defined for the Application class, i.e. the value of the
* {@code applicationClass} property.
*
* return getResourceManager().getResourceMap();
*
*
* @return the Application's ResourceMap
* @see ResourceManager#getResourceMap()
* @see #getApplicationClass
*/
public final ResourceMap getResourceMap() {
return getResourceManager().getResourceMap();
}
/**
* Return this application's ActionManager.
* @return this application's ActionManager.
* @see #getActionMap(Object)
*/
public final ActionManager getActionManager() {
return actionManager;
}
/**
* Change this application's {@code ActionManager}. An
* {@code ApplicationContext} subclass that
* wanted to fundamentally change the way {@code ActionManagers} were
* created and cached could replace this property in its constructor.
*
* return getActionManager().getActionMap()
*
*
* @return the {@code ActionMap} chain for the entire {@code Application}.
* @see ActionManager#getActionMap()
*/
public final ApplicationActionMap getActionMap() {
return getActionManager().getActionMap();
}
/**
* Returns the {@code ApplicationActionMap} chain for the specified
* actions class and target object.
*
* return getActionManager().getActionMap(actionsClass, actionsObject)
*
*
* @param actionsClass
* @param actionsObject
* @return the {@code ActionMap} chain for the entire {@code Application}.
* @see ActionManager#getActionMap(Class, Object)
*/
public final ApplicationActionMap getActionMap(Class actionsClass, Object actionsObject) {
return getActionManager().getActionMap(actionsClass, actionsObject);
}
/**
* Defined as {@code getActionMap(actionsObject.getClass(), actionsObject)}.
*
* @param actionsObject
* @return the {@code ActionMap} for the specified object
* @see #getActionMap(Class, Object)
*/
public final ApplicationActionMap getActionMap(Object actionsObject) {
if (actionsObject == null) {
throw new IllegalArgumentException("null actionsObject");
}
return getActionManager().getActionMap(actionsObject.getClass(), actionsObject);
}
/**
* The shared {@link LocalStorage LocalStorage} object.
*
* @return the shared {@link LocalStorage LocalStorage} object.
*/
public final LocalStorage getLocalStorage() {
return localStorage;
}
/**
* The shared {@link LocalStorage LocalStorage} object.
*
* @param localStorage the shared {@link LocalStorage LocalStorage} object.
*/
protected void setLocalStorage(LocalStorage localStorage) {
if (localStorage == null) {
throw new IllegalArgumentException("null localStorage");
}
Object oldValue = this.localStorage;
this.localStorage = localStorage;
firePropertyChange("localStorage", oldValue, this.localStorage);
}
/**
* The shared {@link SessionStorage SessionStorage} object.
*
* @return the shared {@link SessionStorage SessionStorage} object.
*/
public final SessionStorage getSessionStorage() {
return sessionStorage;
}
/**
* The shared {@link SessionStorage SessionStorage} object.
*
* @param sessionStorage the shared {@link SessionStorage SessionStorage} object.
*/
protected void setSessionStorage(SessionStorage sessionStorage) {
if (sessionStorage == null) {
throw new IllegalArgumentException("null sessionStorage");
}
Object oldValue = this.sessionStorage;
this.sessionStorage = sessionStorage;
firePropertyChange("sessionStorage", oldValue, this.sessionStorage);
}
/**
* Return a shared {@code Clipboard}.
* @return A shared {@code Clipboard}.
*/
public Clipboard getClipboard() {
if (clipboard == null) {
try {
clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
} catch (SecurityException e) {
clipboard = new Clipboard("sandbox");
}
}
return clipboard;
}
/**
* Returns the application's focus owner.
* @return The application's focus owner.
*/
public JComponent getFocusOwner() {
return focusOwner;
}
/**
* Changes the application's focus owner.
* @param focusOwner new focus owner
*/
void setFocusOwner(JComponent focusOwner) {
Object oldValue = this.focusOwner;
this.focusOwner = focusOwner;
firePropertyChange("focusOwner", oldValue, this.focusOwner);
}
private Listreturn getTaskService("default"). The
* {@link ApplicationAction#actionPerformed ApplicationAction actionPerformed}
* method executes background Tasks on the default
* TaskService. Application's can launch Tasks in the same way, e.g.
*
* Application.getInstance().getContext().getTaskService().execute(myTask);
*
*
* @return the default TaskService.
* @see #getTaskService(String)
*
*/
public final TaskService getTaskService() {
return getTaskService("default");
}
/**
* Returns a read-only view of the complete list of TaskServices.
*
* @return a list of all of the TaskServices.
* @see #addTaskService
* @see #removeTaskService
*/
public List
* @Override protected void startup() {
* getFrame().setJMenuBar(createMenuBar());
* show(createMainPanel());
* }
*
*
* @return this application's main frame
*/
public JFrame getFrame() {
if (frame == null) {
ResourceMap resourceMap = getContext().getResourceMap();
String title = resourceMap.getString(KEY_APPLICATION_TITLE);
frame = new JFrame(title);
frame.setName(MAIN_FRAME_NAME);
if (resourceMap.containsKey(KEY_APPLICATION_ICON)) {
Image icon = resourceMap.getImageIcon(KEY_APPLICATION_ICON).getImage();
frame.setIconImage(icon);
}
}
return frame;
}
/**
* Sets the JFrame use to show this View
* true, then bytes will be written
* to the end of the output entry rather than the beginning
* @return an {@code OutputStream} object
* @throws IOException if the specified name is invalid,
* or an output stream cannot be opened
*/
public OutputStream openOutputFile(String fileName, boolean append) throws IOException {
checkFileName(fileName);
return getLocalIO().openOutputFile(fileName, append);
}
/**
* Deletes the entry specified by the {@code name} parameter.
*
* @param fileName the storage-dependent name
* @throws IOException if the specified name is invalid,
* or an internal entry cannot be deleted
*/
public boolean deleteFile(String fileName) throws IOException {
checkFileName(fileName);
return getLocalIO().deleteFile(fileName);
}
/* If an exception occurs in the XMLEncoder/Decoder, we want
* to throw an IOException. The exceptionThrow listener method
* doesn't throw a checked exception so we just set a flag
* here and check it when the encode/decode operation finishes
*/
private static class AbortExceptionListener implements ExceptionListener {
public Exception exception = null;
@Override
public void exceptionThrown(Exception e) {
if (exception == null) {
exception = e;
}
}
}
private static boolean persistenceDelegatesInitialized = false;
/**
* Saves the {@code bean} to the local storage
* @param bean the object ot be saved
* @param fileName the targen file name
* @throws IOException
*/
public void save(Object bean, final String fileName) throws IOException {
AbortExceptionListener el = new AbortExceptionListener();
XMLEncoder e = null;
/* Buffer the XMLEncoder's output so that decoding errors don't
* cause us to trash the current version of the specified file.
*/
ByteArrayOutputStream bst = new ByteArrayOutputStream();
try {
e = new XMLEncoder(bst);
if (!persistenceDelegatesInitialized) {
e.setPersistenceDelegate(Rectangle.class, new RectanglePD());
persistenceDelegatesInitialized = true;
}
e.setExceptionListener(el);
e.writeObject(bean);
} finally {
if (e != null) {
e.close();
}
}
if (el.exception != null) {
throw new LSException("save failed \"" + fileName + "\"", el.exception);
}
OutputStream ost = null;
try {
ost = openOutputFile(fileName);
ost.write(bst.toByteArray());
} finally {
if (ost != null) {
ost.close();
}
}
}
/**
* Loads the been from the local storage
* @param fileName name of the file to be read from
* @return loaded object
* @throws IOException
*/
public Object load(String fileName) throws IOException {
InputStream ist;
try {
ist = openInputFile(fileName);
} catch (IOException e) {
return null;
}
AbortExceptionListener el = new AbortExceptionListener();
XMLDecoder d = null;
try {
d = new XMLDecoder(ist);
d.setExceptionListener(el);
Object bean = d.readObject();
if (el.exception != null) {
throw new LSException("load failed \"" + fileName + "\"", el.exception);
}
return bean;
} finally {
if (d != null) {
d.close();
}
}
}
// private void closeStream(Closeable st, String fileName) throws IOException {
// if (st != null) {
// try {
// st.close();
// } catch (java.io.IOException e) {
// throw new LSException("close failed \"" + fileName + "\"", e);
// }
// }
// }
/**
* Gets the limit of the local storage
* @return the limit of the local storage
*/
public long getStorageLimit() {
return storageLimit;
}
/**
* Sets the limit of the lical storage
* @param storageLimit the limit of the lical storage
*/
public void setStorageLimit(long storageLimit) {
if (storageLimit < -1L) {
throw new IllegalArgumentException("invalid storageLimit");
}
long oldValue = this.storageLimit;
this.storageLimit = storageLimit;
firePropertyChange("storageLimit", oldValue, this.storageLimit);
}
private String getId(String key, String def) {
ResourceMap appResourceMap = getContext().getResourceMap();
String id = appResourceMap.getString(key);
if (id == null) {
logger.log(Level.WARNING, "unspecified resource " + key + " using " + def);
id = def;
} else if (id.trim().length() == 0) {
logger.log(Level.WARNING, "empty resource " + key + " using " + def);
id = def;
}
return id;
}
private String getApplicationId() {
return getId("Application.id", getContext().getApplicationClass().getSimpleName());
}
private String getVendorId() {
return getId(KEY_APPLICATION_VENDOR_ID, "UnknownApplicationVendor");
}
/**
* Returns the directory where the local storage is located
* @return the directory where the local storage is located
*/
public File getDirectory() {
if (directory == unspecifiedFile) {
directory = null;
String userHome = null;
try {
userHome = System.getProperty("user.home");
} catch (SecurityException ignore) {
}
if (userHome != null) {
final String applicationId = getApplicationId();
final PlatformType osId = AppHelper.getPlatform();
if (osId == PlatformType.WINDOWS) {
File appDataDir = null;
try {
String appDataEV = System.getenv("APPDATA");
if ((appDataEV != null) && (appDataEV.length() > 0)) {
appDataDir = new File(appDataEV);
}
} catch (SecurityException ignore) {
}
String vendorId = getVendorId();
if ((appDataDir != null) && appDataDir.isDirectory()) {
// ${APPDATA}\{vendorId}\${applicationId}
String path = vendorId + "\\" + applicationId + "\\";
directory = new File(appDataDir, path);
} else {
// ${userHome}\Application Data\${vendorId}\${applicationId}
String path = "Application Data\\" + vendorId + "\\" + applicationId + "\\";
directory = new File(userHome, path);
}
} else if (osId == PlatformType.OS_X) {
// ${userHome}/Library/Application Support/${applicationId}
String path = "Library/Application Support/" + applicationId + "/";
directory = new File(userHome, path);
} else {
// ${userHome}/.${applicationId}/
String path = "." + applicationId + "/";
directory = new File(userHome, path);
}
}
}
return directory;
}
/**
* Sets the location of the local storage
* @param directory the location of the local storage
*/
public void setDirectory(File directory) {
File oldValue = this.directory;
this.directory = directory;
firePropertyChange("directory", oldValue, this.directory);
}
//TODO: Use IOException instead
/* Papers over the fact that the String,Throwable IOException
* constructor was only introduced in Java 6.
*/
private static class LSException extends IOException {
public LSException(String s, Throwable e) {
super(s);
initCause(e);
}
public LSException(String s) {
super(s);
}
}
/* There are some (old) Java classes that aren't proper beans. Rectangle
* is one of these. When running within the secure sandbox, writing a
* Rectangle with XMLEncoder causes a security exception because
* DefaultPersistenceDelegate calls Field.setAccessible(true) to gain
* access to private fields. This is a workaround for that problem.
* A bug has been filed, see JDK bug ID 4741757
*/
private static class RectanglePD extends DefaultPersistenceDelegate {
public RectanglePD() {
super(new String[]{"x", "y", "width", "height"});
}
@Override
protected Expression instantiate(Object oldInstance, Encoder out) {
Rectangle oldR = (Rectangle) oldInstance;
Object[] constructorArgs = new Object[]{
oldR.x, oldR.y, oldR.width, oldR.height
};
return new Expression(oldInstance, oldInstance.getClass(), "new", constructorArgs);
}
}
private synchronized LocalIO getLocalIO() {
if (localIO == null) {
localIO = getPersistenceServiceIO();
if (localIO == null) {
localIO = new LocalFileIO();
}
}
return localIO;
}
private abstract class LocalIO {
/**
* Opens an input stream to read from the entry
* specified by the {@code name} parameter.
* If the named entry cannot be opened for reading
* then a {@code IOException} is thrown.
*
* @param fileName the storage-dependent name
* @return an {@code InputStream} object
* @throws IOException if the specified name is invalid,
* or an input stream cannot be opened
*/
public abstract InputStream openInputFile(String fileName) throws IOException;
/**
* Opens an output stream to write to the entry
* specified by the {@code name} parameter.
* If the named entry cannot be opened for writing
* then a {@code IOException} is thrown.
* If the named entry does not exist it can be created.
* The entry will be recreated if already exists.
*
* @param fileName the storage-dependent name
* @return an {@code OutputStream} object
* @throws IOException if the specified name is invalid,
* or an output stream cannot be opened
*/
public OutputStream openOutputFile(final String fileName) throws IOException {
return openOutputFile(fileName, false);
}
/**
* Opens an output stream to write to the entry
* specified by the {@code name} parameter.
* If the named entry cannot be opened for writing
* then a {@code IOException} is thrown.
* If the named entry does not exist it can be created.
* You can decide whether data will be appended via append parameter.
*
* @param fileName the storage-dependent name
* @param append if true, then bytes will be written
* to the end of the output entry rather than the beginning
* @return an {@code OutputStream} object
* @throws IOException if the specified name is invalid,
* or an output stream cannot be opened
*/
public abstract OutputStream openOutputFile(final String fileName, boolean append) throws IOException;
/**
* Deletes the entry specified by the {@code name} parameter.
*
* @param fileName the storage-dependent name
* @throws IOException if the specified name is invalid,
* or an internal entry cannot be deleted
*/
public abstract boolean deleteFile(String fileName) throws IOException;
}
private final class LocalFileIO extends LocalIO {
@Override
public InputStream openInputFile(String fileName) throws IOException {
File path = getFile(fileName);
try {
return new BufferedInputStream(new FileInputStream(path));
} catch (IOException e) {
throw new LSException("couldn't open input file \"" + fileName + "\"", e);
}
}
@Override
public OutputStream openOutputFile(String name, boolean append) throws IOException {
try {
File file = getFile(name);
File dir = file.getParentFile();
if (!dir.isDirectory() && !dir.mkdirs()) {
throw new IOException("couldn't create directory " + dir);
}
return new BufferedOutputStream(new FileOutputStream(file, append));
}
catch (SecurityException exception) {
throw new IOException("could not write to entry: " + name, exception);
}
}
@Override
public boolean deleteFile(String fileName) throws IOException {
File path = new File(getDirectory(), fileName);
return path.delete();
}
private File getFile(String name) throws IOException {
if (name == null) {
throw new IOException("name is not set");
}
return new File(getDirectory(), name);
}
}
/* Determine if we're a web started application and the
* JNLP PersistenceService is available without forcing
* the JNLP API to be class-loaded. We don't want to
* require apps that aren't web started to bundle javaws.jar
*/
private LocalIO getPersistenceServiceIO() {
try {
Class smClass = Class.forName("javax.jnlp.ServiceManager");
Method getServiceNamesMethod = smClass.getMethod("getServiceNames");
String[] serviceNames = (String[]) getServiceNamesMethod.invoke(null);
boolean psFound = false;
boolean bsFound = false;
for (String serviceName : serviceNames) {
if (serviceName.equals("javax.jnlp.BasicService")) {
bsFound = true;
} else if (serviceName.equals("javax.jnlp.PersistenceService")) {
psFound = true;
}
}
if (bsFound && psFound) {
return new PersistenceServiceIO();
}
} catch (Exception ignore) {
// either the classes or the services can't be found
}
return null;
}
private final class PersistenceServiceIO extends LocalIO {
private BasicService bs;
private PersistenceService ps;
private String initFailedMessage(String s) {
return getClass().getName() + " initialization failed: " + s;
}
PersistenceServiceIO() {
try {
bs = (BasicService) ServiceManager.lookup("javax.jnlp.BasicService");
ps = (PersistenceService) ServiceManager.lookup("javax.jnlp.PersistenceService");
} catch (UnavailableServiceException e) {
logger.log(Level.SEVERE, initFailedMessage("ServiceManager.lookup"), e);
bs = null;
ps = null;
}
}
private void checkBasics(String s) throws IOException {
if ((bs == null) || (ps == null)) {
throw new IOException(initFailedMessage(s));
}
}
private URL fileNameToURL(String name) throws IOException {
if (name == null) {
throw new IOException("name is not set");
}
try {
return new URL(bs.getCodeBase(), name);
} catch (MalformedURLException e) {
throw new LSException("invalid filename \"" + name + "\"", e);
}
}
@Override
public InputStream openInputFile(String fileName) throws IOException {
checkBasics("openInputFile");
URL fileURL = fileNameToURL(fileName);
try {
return new BufferedInputStream(ps.get(fileURL).getInputStream());
} catch (Exception e) {
throw new LSException("openInputFile \"" + fileName + "\" failed", e);
}
}
@Override
public OutputStream openOutputFile(String fileName, boolean append) throws IOException {
checkBasics("openOutputFile");
URL fileURL = fileNameToURL(fileName);
try {
FileContents fc = null;
try {
fc = ps.get(fileURL);
} catch (FileNotFoundException e) {
/* Verify that the max size for new PersistenceService
* files is >= 100K (2^17) before opening one.
*/
long maxSizeRequest = 131072L;
long maxSize = ps.create(fileURL, maxSizeRequest);
if (maxSize >= maxSizeRequest) {
fc = ps.get(fileURL);
}
}
if ((fc != null) && (fc.canWrite())) {
return new BufferedOutputStream(fc.getOutputStream(!append));
} else {
throw new IOException("unable to create FileContents object");
}
} catch (Exception e) {
throw new LSException("openOutputFile \"" + fileName + "\" failed", e);
}
}
@Override
public boolean deleteFile(String fileName) throws IOException {
checkBasics("deleteFile");
URL fileURL = fileNameToURL(fileName);
try {
ps.delete(fileURL);
return true;
} catch (Exception e) {
throw new LSException("openInputFile \"" + fileName + "\" failed", e);
}
}
}
}
bsaf-1.9/src/main/java/org/jdesktop/application/MnemonicText.java 0000664 0000000 0000000 00000011343 11516403062 0025124 0 ustar 00root root 0000000 0000000
/*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.application;
import java.awt.event.KeyEvent;
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;
import javax.swing.AbstractButton;
import javax.swing.JLabel;
/**
* An internal helper class that configures the text and mnemonic
* properties for instances of AbstractButton, JLabel, and
* javax.swing.Action. It's used like this:
*
* MnemonicText.configure(myButton, "Save &As")
*
* The configure method unconditionally sets three properties on the
* target object:
*
*
* If the mnemonic marker character isn't present, then the second
* two properties are cleared to VK_UNDEFINED (0) and -1 respectively.
*
* <classname>.<fieldname>
*
*
* @author Hans Muller (Hans.Muller@Sun.COM)
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Resource {
/**
* Key for resource injection. If not specified the name of the field will be used.
*/
String key() default "";
}
bsaf-1.9/src/main/java/org/jdesktop/application/ResourceConverter.java 0000664 0000000 0000000 00000027667 11516403062 0026211 0 ustar 00root root 0000000 0000000
/*
* Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. Use is
* subject to license terms.
*/
package org.jdesktop.application;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* A base class for converting arbitrary types to and from Strings, as well as
* a registry of ResourceConverter implementations.
*
*
*
* ApplicationContext appContext = Application.getInstance().getContext();
* ResourceMap resourceMap = appContext.getResourceMap(MyClass.class);
* String msg = resourceMap.getString("msg");
* Icon icon = resourceMap.getIcon("icon");
* Color color = resourceMap.getColor("color");
*
* {@link ApplicationContext#getResourceMap(Class) ApplicationContext.getResourceMap()}
* just delegates to its {@code ResourceManager}. The {@code ResourceMap}
* in this example contains resources from the ResourceBundle named
* {@code MyClass}, and the rest of the
* chain contains resources shared by the entire application.
*
* Application.getInstance().getContext().getResourceManager()
*
* Or just look up {@code ResourceMaps} with the ApplicationContext
* convenience method:
*
* Application.getInstance().getContext().getResourceMap(MyClass.class)
*
*
* FIXME - @param javadoc
* @param context
* @see ApplicationContext#getResourceManager
* @see ApplicationContext#getResourceMap
*/
protected ResourceManager(ApplicationContext context) {
if (context == null) {
throw new IllegalArgumentException("null context");
}
this.context = context;
resourceMaps = new ConcurrentHashMap
*
*
*
*
*
* ResourceMap
* ResourceBundle names
* Typical ResourceBundle files
*
*
* 1
* class: com.myco.MyScreen
* com.myco.resources.MyScreen
* com/myco/resources/MyScreen.properties
*
*
* 2/td>
* application: com.myco.MyApp
* com.myco.resources.MyApp
* com/myco/resources/MyApp.properties
*
*
* 3
* application: javax.swing.application.Application
* javax.swing.application.resources.Application
* javax.swing.application.resources.Application.properties
* getResourceMap(cls, cls).
*
* @param cls the class that defines the location of ResourceBundles
* @return a {@code ResourceMap} that contains resources loaded from
* {@code ResourceBundles} found in the resources subpackage of the
* specified class's package.
* @see #getResourceMap(Class, Class)
*/
public final ResourceMap getResourceMap(Class cls) {
if (cls == null) {
throw new IllegalArgumentException("null class");
}
return getResourceMap(cls, cls);
}
/**
* Returns the chain of ResourceMaps that's shared by the entire application,
* beginning with the resources defined for the application's class, i.e.
* the value of the ApplicationContext
* {@link ApplicationContext#getApplicationClass applicationClass} property.
* If the {@code applicationClass} property has not been set, e.g. because
* the application has not been {@link Application#launch launched} yet,
* then a ResourceMap for just {@code Application.class} is returned.
*
* @return the Application's ResourceMap
* @see ApplicationContext#getResourceMap()
* @see ApplicationContext#getApplicationClass
*/
public ResourceMap getResourceMap() {
return getApplicationResourceMap();
}
/**
* The names of the ResourceBundles to be shared by the entire
* application. The list is in priority order: resources defined
* by the first ResourceBundle shadow resources with the the same
* name that come later.
*
*
* return new ResourceMap(parent, classLoader, bundleNames);
*
* Custom ResourceManagers might override this method to construct their
* own ResourceMap subclasses.
* @param classLoader the ClassLoader to be used to load the ResourceBundle
* @param parent parent ResourceMap or null
* @param bundleNames names of the ResourceBundle to be loaded
* @return a new resource map
*/
protected ResourceMap createResourceMap(ClassLoader classLoader, ResourceMap parent, List
* myLabel.text.osx = A value that's appropriate for OSX
* myLabel.text.default = A value for other platforms
* myLabel.text = myLabel.text.${platform}
*
* this(parent, classLoader, Arrays.asList(bundleNames)).
* @param parent
* @param classLoader
* @param bundleNames
*/
public ResourceMap(ResourceMap parent, ClassLoader classLoader, String... bundleNames) {
this(parent, classLoader, Arrays.asList(bundleNames));
}
/**
* Returns the parent ResourceMap, or null. Logically, this ResourceMap
* contains all of the resources defined here and (recursively) in the
* parent.
*
* @return the parent ResourceMap or null
*/
public ResourceMap getParent() {
return parent;
}
/**
* Returns the names of the ResourceBundles that define the
* resources contained by this ResourceMap.
*
* @return the names of the ResourceBundles in this ResourceMap
*/
public List
* String filename = myResourceMap.getResourcesDir() + "myIcon.png";
* URL url = myResourceMap.getClassLoader().getResource(filename);
* new ImageIcon(iconURL);
*
*
* @return the the resources directory for this ResourceMap
*/
public String getResourcesDir() {
return resourcesDir;
}
/* Lazily flattens all of the ResourceBundles named in bundleNames
* into a single Map - bundlesMapP. The bundleNames list is in
* priority order, the first entry shadows later entries.
*/
private synchronized Map
* Application.title = My Application
* ErrorDialog.title = Error: ${application.title}
* WarningDialog.title = Warning: ${application.title}
*
* The value of "WarningDialog.title" would be
* "Warning: My Application". To include "${" in a
* resource, insert a backslash before the "$". For example, the
* value of escString in the example below, would
* be "${hello}":
*
* escString = \\${hello}
*
* Note that, in a properties file, the backslash character is
* used for line continuation, so we've had to escape that too.
* If the value of a resource is the special variable ${null},
* then the resource will be removed from this ResourceMap.
*
* hello = Hello %s
*
* then the value of getString("hello", "World") would
* be "Hello World".
*
* @param key
* @param args
* @return the String value of the resource named key
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
* @see #getObject
* @see String#format(String, Object...)
*/
public String getString(String key, Object... args) {
if (args.length == 0) {
return (String) getObject(key, String.class);
} else {
String format = (String) getObject(key, String.class);
return (format == null) ? null : String.format(format, args);
}
}
/**
* A convenience method that's shorthand for calling:
* getObject(key, Boolean.class).
*
* @param key the name of the resource
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
* @return the Boolean value of the resource named key
* @see #getObject
*/
public final Boolean getBoolean(String key) {
return (Boolean) getObject(key, Boolean.class);
}
/**
* A convenience method that's shorthand for calling:
* getObject(key, Integer.class).
*
* @param key the name of the resource
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
* @return the Integer value of the resource named key
* @see #getObject
*/
public final Integer getInteger(String key) {
return (Integer) getObject(key, Integer.class);
}
/**
* A convenience method that's shorthand for calling:
* getObject(key, Long.class).
*
* @param key the name of the resource
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
* @return the Long value of the resource named key
* @see #getObject
*/
public final Long getLong(String key) {
return (Long) getObject(key, Long.class);
}
/**
* A convenience method that's shorthand for calling:
* getObject(key, Short.class).
*
* @param key the name of the resource
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
* @return the Short value of the resource named key
* @see #getObject
*/
public final Short getShort(String key) {
return (Short) getObject(key, Short.class);
}
/**
* A convenience method that's shorthand for calling:
* getObject(key, Byte.class).
*
* @param key the name of the resource
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
* @return the Byte value of the resource named key
* @see #getObject
*/
public final Byte getByte(String key) {
return (Byte) getObject(key, Byte.class);
}
/**
* A convenience method that's shorthand for calling:
* getObject(key, Float.class).
*
* @param key the name of the resource
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
* @return the Float value of the resource named key
* @see #getObject
*/
public final Float getFloat(String key) {
return (Float) getObject(key, Float.class);
}
/**
* A convenience method that's shorthand for calling:
* getObject(key, Double.class).
*
* @param key the name of the resource
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
* @return the Double value of the resource named key
* @see #getObject
*/
public final Double getDouble(String key) {
return (Double) getObject(key, Double.class);
}
/**
*
* A convenience method that's shorthand for calling:
* getObject(key, Icon.class). This method
* relies on the ImageIcon ResourceConverter that's registered
* by this class. See {@link #getImageIcon} for more information.
*
*
* @param key the name of the resource
* @return the Icon value of the resource named key
* @see #getObject
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
*/
public final Icon getIcon(String key) {
return (Icon) getObject(key, Icon.class);
}
/**
*
* A convenience method that's shorthand for calling:
* getObject(key, ImageIcon.class). This method
* relies on the ImageIcon ResourceConverter that's registered
* by this class.
*
* openIcon = myOpenIcon.png
*
* then resourceMap.getIcon("openIcon") would load
* the image file called "myOpenIcon.png" from the resources
* subdirectory, effectively like this:
*
* String filename = myResourceMap.getResourcesDir() + "myOpenIcon.png";
* URL url = myResourceMap.getClassLoader().getResource(filename);
* new ImageIcon(iconURL);
*
*
*
* @param key the name of the resource
* @return the ImageIcon value of the resource named key
* @see #getObject
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
*/
public final ImageIcon getImageIcon(String key) {
return (ImageIcon) getObject(key, ImageIcon.class);
}
/**
*
* A convenience method that's shorthand for calling:
* getObject(key, Font.class). This method relies
* on the Font ResourceConverter that's registered by this class.
* Font resources may be defined with strings that are
* recognized by {@link Font#decode},
* face-STYLE-size.
* For example:
*
* myFont = Arial-PLAIN-12
*
*
*
* @param key the name of the resource
* @return the Font value of the resource named key
* @see #getObject
* @see ResourceConverter#forType
* @see Font#decode
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalResourceConverteron if key is null
*/
public final Font getFont(String key) {
return (Font) getObject(key, Font.class);
}
/**
*
* A convenience method that's shorthand for calling:
* getObject(key, Color.class). This method relies on the
* Color ResourceConverter that's registered by this class. It defines
* an improved version of Color.decode()
* that supports colors with an alpha channel and comma
* separated RGB[A] values. Legal format for color resources are:
*
* myHexRGBColor = #RRGGBB
* myHexAlphaRGBColor = #AARRGGBB
* myRGBColor = R, G, B
* myAlphaRGBColor = R, G, B, A
*
* The first two examples, with the leading "#" encode the color
* with 3 or 4 hex values and the latter with integer values between
* 0 and 255. In both cases the value represented by "A" is the
* color's (optional) alpha channel.
*
*
* @param key the name of the resource
* @return the Color value of the resource named key
* @see #getObject
* @see ResourceConverter#forType
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException ResourceConverter is null
*/
public final Color getColor(String key) {
return (Color) getObject(key, Color.class);
}
/**
*
* A convenience method that's shorthand for calling:
* getObject(key, KeyStroke.class). This method relies on the
* KeyStroke ResourceConverter that's registered by this class and
* uses {@link KeyStroke#getKeyStroke(String s)} to convert strings.
*
* For example, pressed F reports the "F" key, and control
* pressed F reports Control-F. See the KeyStroke JavaDoc for
* more information.
*
* @param key the name of the resource
* @return the KeyStroke value of the resource named key
* @see #getObject
* @see KeyStroke#getKeyStroke
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
*/
public final KeyStroke getKeyStroke(String key) {
return (KeyStroke) getObject(key, KeyStroke.class);
}
/**
* A convenience method that's shorthand for calling:
* getKeyStroke(key).getKeyCode(). If there's
* no resource named key then null is returned.
*
* @param key the name of the resource
* @throws LookupException if an error occurs during lookup or string conversion
* @throws IllegalArgumentException if key is null
* @return the KeyCode value of the resource named key
* @see #getObject
*/
public Integer getKeyCode(String key) {
KeyStroke ks = getKeyStroke(key);
return (ks != null) ? ks.getKeyCode() : null;
}
/**
* Unchecked exception thrown by {@link #injectComponent} and
* {@link #injectComponents} when a property value specified by
* a resource can not be set.
*
* @see #injectComponent
* @see #injectComponents
*/
public static class PropertyInjectionException extends RuntimeException {
private final String key;
private final Component component;
private final String propertyName;
/**
* Constructs an instance of this class with some useful information
* about the failure.
*
* @param msg the detail message
* @param key the name of the resource
* @param component the component whose property couldn't be set
* @param propertyName the name of the component property
*/
public PropertyInjectionException(String msg, String key, Component component, String propertyName) {
super(String.format("%s: resource %s, property %s, component %s", msg, key, propertyName, component));
this.key = key;
this.component = component;
this.propertyName = propertyName;
}
/**
* Returns the the name of resource whose value was to be used to set the property
* @return the resource name
*/
public String getKey() {
return key;
}
/**
* Returns the component whose property could not be set
* @return the component
*/
public Component getComponent() {
return component;
}
/**
* Returns the the name of property that could not be set
* @return the property name
*/
public String getPropertyName() {
return propertyName;
}
}
private void injectComponentProperty(Component component, PropertyDescriptor pd, String key) {
Method setter = pd.getWriteMethod();
Class type = pd.getPropertyType();
if ((setter != null) && (type != null) && containsKey(key)) {
Object value = getObject(key, type);
String propertyName = pd.getName();
try {
// Note: this could be generalized, we could delegate
// to a component property injector.
if ("text".equals(propertyName) && (component instanceof AbstractButton)) {
MnemonicText.configure(component, (String) value);
} else if ("text".equals(propertyName) && (component instanceof JLabel)) {
MnemonicText.configure(component, (String) value);
} else {
setter.invoke(component, value);
}
} catch (Exception e) {
String pdn = pd.getName();
String msg = "property setter failed";
RuntimeException re = new PropertyInjectionException(msg, key, component, pdn);
re.initCause(e);
throw re;
}
} else if (type != null) {
String pdn = pd.getName();
String msg = "no value specified for resource";
throw new PropertyInjectionException(msg, key, component, pdn);
} else if (setter == null) {
String pdn = pd.getName();
String msg = "can't set read-only property";
throw new PropertyInjectionException(msg, key, component, pdn);
}
}
private void injectComponentProperties(Component component) {
String componentName = component.getName();
if (componentName != null) {
/* Optimization: punt early if componentName doesn't
* appear in any componentName.propertyName resource keys
*/
boolean matchingResourceFound = false;
for (String key : keySet()) {
int i = key.lastIndexOf(".");
if ((i != -1) && componentName.equals(key.substring(0, i))) {
matchingResourceFound = true;
break;
}
}
if (!matchingResourceFound) {
return;
}
BeanInfo beanInfo;
try {
beanInfo = Introspector.getBeanInfo(component.getClass());
} catch (IntrospectionException e) {
String msg = "introspection failed";
RuntimeException re = new PropertyInjectionException(msg, null, component, null);
re.initCause(e);
throw re;
}
PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
if ((pds != null) && (pds.length > 0)) {
for (String key : keySet()) {
int i = key.lastIndexOf(".");
String keyComponentName = (i == -1) ? null : key.substring(0, i);
if (componentName.equals(keyComponentName)) {
if ((i + 1) == key.length()) {
/* key has no property name suffix, e.g. "myComponentName."
* This is probably a mistake.
*/
String msg = "component resource lacks property name suffix";
logger.warning(msg);
break;
}
String propertyName = key.substring(i + 1);
boolean matchingPropertyFound = false;
for (PropertyDescriptor pd : pds) {
if (pd.getName().equals(propertyName)) {
injectComponentProperty(component, pd, key);
matchingPropertyFound = true;
break;
}
}
if (!matchingPropertyFound) {
String msg = String.format(
"[resource %s] component named %s doesn't have a property named %s",
key, componentName, propertyName);
logger.warning(msg);
}
}
}
}
}
}
/**
* Set each property in target to the value of
* the resource named componentName.propertyName,
* where componentName is the value of the
* target component's name property, i.e. the value of
* target.getName(). The type of the resource must
* match the type of the corresponding property. Properties
* that aren't defined by a resource aren't set.
*
* myButton = new JButton();
* myButton.setName("myButton");
*
* And a ResourceBundle properties file with the following
* resources:
*
* myButton.text = Hello World
* myButton.foreground = 0, 0, 0
* myButton.preferredSize = 256, 256
*
* Then injectComponent(myButton) would initialize
* myButton's text, foreground, and preferredSize properties
* to Hello World, new Color(0,0,0), and
* new Dimension(256,256) respectively.
*
* class MyClass {
* @Resource String sOne;
* @Resource(key="sTwo") String s2;
* @Resource int[] numbers = new int[2];
* }
*
* Given the previous class and the following resource file:
*
* MyClass.sOne = One
* sTwo = Two
* MyClass.numbers[0] = 10
* MyClass.numbers[1] = 11
*
* Then injectFields(new MyClass()) would initialize the MyClass
* sOne field to "One", the s2 field to "Two", and the
* two elements of the numbers array to 10 and 11.
*
* public class MyApplication extends Application {
* @Override protected void shutdown() {
* getContext().getSessionStorage().save(mainFrame, "session.xml");
* }
* @Override protected void startup() {
* ApplicationContext appContext = getContext();
* appContext.setVendorId("Sun");
* appContext.setApplicationId("SessionStorage1");
* // ... create the GUI rooted by JFrame mainFrame
* appContext.getSessionStorage().restore(mainFrame, "session.xml");
* }
* // ...
* }
*
* In this example, the bounds of {@code mainFrame} as well the
* session state for any of its {@code JSliderPane} or {@code
* JTabbedPane} will be saved when the application shuts down, and
* restored when the applications starts up again. Note: error
* handling has been omitted from the example.
*
* ${userHome}\Application Data\${vendorId}\${applicationId}\session.xml
*
* Where the value of {@code ${userHome}} is the the value of
* the Java System property {@code "user.home"}. On Solaris or
* Linux the file is:
*
* ${userHome}/.${applicationId}/session.xml
*
* and on OSX:
*
* ${userHome}/Library/Application Support/${applicationId}/session.xml
*
*
* @see ApplicationContext#getSessionStorage
* @see LocalStorage
*/
public class SessionStorage {
private static Logger logger = Logger.getLogger(SessionStorage.class.getName());
private final Map
*
*
*
* Base Component Type
* PropertySupport
* PropertySupport Value
*
*
* Window
* WindowProperty
* WindowState
*
*
* JTabbedPane
* TabbedPaneProperty
* TabbedPaneState
*
*
* JSplitPane
* SplitPaneProperty
* SplitPaneState
*
*
* JTable
* TableProperty
* TableState
*
* ApplicationContext ctx = Application.getInstance(MyApplication.class).getContext();
* SessionStorage ss = ctx.getSesssionStorage();
*
*
*
* @param context
* @see ApplicationContext#getSessionStorage
* @see #getProperty(Class)
* @see #getProperty(Component)
*/
protected SessionStorage(ApplicationContext context) {
if (context == null) {
throw new IllegalArgumentException("null context");
}
this.context = context;
propertyMap = new HashMap
* public class FooBar {
* private String foo, bar;
* // Defines the mapping from constructor params to properties
* @ConstructorProperties({"foo", "bar"})
* public FooBar(String foo, String bar) {
* this.foo = foo;
* this.bar = bar;
* }
* public String getFoo() { return foo; } // don't need setFoo
* public String getBar() { return bar; } // don't need setBar
* }
*
*
* @param root the root of the Component hierarchy to be saved.
* @param fileName the {@code LocalStorage} filename.
* @throws IOException
* @see #restore
* @see ApplicationContext#getLocalStorage
* @see LocalStorage#save
* @see #getProperty(Component)
*/
public void save(Component root, String fileName) throws IOException {
checkSaveRestoreArgs(root, fileName);
Map
* sessionStorage.putProperty(myClass.class, null);
*
*
* Register a custom {@code PropertySupport}:
*
* ApplicationContext ctx = Application.getInstance(MyApplication.class).getContext();
* SessionStorage ss = ctx.getSesssionStorage();
* ctx.putProperty(JTable.class, new ExtendedTableProperty());
*
*
* @exception IllegalArgumentException if {@code cls} is null.
* @param cls the class to which {@code propertySupport} applies.
* @param propertySupport the {@code PropertySupport} object to register or null.
* @see #getProperty(Component)
* @see #getProperty(Class)
* @see #save
* @see #restore
*/
public void putProperty(Class cls, PropertySupport propertySupport) {
checkClassArg(cls);
// Remove property support for the clazz in case property argument is null
if (propertySupport == null) {
propertyMap.remove(cls);
return;
}
propertyMap.put(cls, propertySupport);
}
/**
* If a {@code sessionState PropertySupport} object exists for the
* specified Component return it, otherwise return null. This method
* is used by the {@link #save save} and {@link #restore restore} methods
* to lookup the {@code sessionState PropertySupport} object for each component
* to whose session state is to be saved or restored.
*
* myJComponent.putClientProperty(PropertySupport.class, myPropertySupport);
*
* One can also create components that implement the
* {@code PropertySupport} interface directly.
*
* @param component the component to retrive the {@code PropertySupport} from
* @return if {@code component} implements {@code PropertySupport}, then
* {@code component}, if {@code component} is a {@code JComponent} with a
* {@code PropertySupport} valued
* {@link javax.swing.JComponent#getClientProperty client property} under
* (client property key) {@code PropertySupport}, then
* return that, otherwise return the value of
* {@code getProperty(component.getClass())}.
*
*class MyApplication extends SingleFrameApplication {
* @Override protected void startup() {
* show(new JLabel("Hello World"));
* }
*}
*
* The call to {@code show} in this example creates a JFrame (named
* "mainFrame"), that contains the "Hello World" JLabel. Before the
* frame is made visible, the properties of all of the components in
* the hierarchy are initialized with
* {@link ResourceMap#injectComponents ResourceMap.injectComponents}
* and then restored from saved session state (if any) with
* {@link SessionStorage#restore SessionStorage.restore}.
* When the application shuts down, session state is saved.
*
* class MyApplication extends SingleFrameApplication {
* @Override protected void startup() {
* JLabel label = new JLabel();
* label.setName("label");
* show(label);
* }
* }
*
* The ResourceBundle should contain definitions for all of the
* standard Application resources, as well the main frame's title
* and the label's text. Note that the JFrame that's implicitly
* created by the {@code show} method is named "mainFrame".
*
* # resources/MyApplication.properties
* Application.id = MyApplication
* Application.title = My Hello World Application
* Application.version = 1.0
* Application.vendor = Illya Yalovyy
* Application.vendorId = Etf
* Application.homepage = http://kenai.com/projects/bsaf
* Application.description = An example of SingleFrameApplication
* Application.lookAndFeel = system
* Application.icon=app_icon.png
*
* mainFrame.title = ${Application.title} ${Application.version}
* label.text = Hello World
*
*/
public abstract class SingleFrameApplication extends Application {
private static final String INITIALIZATION_MARKER="SingleFrameApplication.initRootPaneContainer";
private static final Logger logger = Logger.getLogger(SingleFrameApplication.class.getName());
/**
* Return the JFrame used to show this application.
*
* protected void startup() {
* getMainFrame().setJMenuBar(createMenuBar());
* show(createMainPanel());
* }
*
*
* @return this application's main frame
* @see #setMainFrame
* @see #show
* @see JFrame#setName
* @see JFrame#setTitle
* @see JFrame#addWindowListener
*/
public final JFrame getMainFrame() {
return getMainView().getFrame();
}
/**
* Sets the JFrame use to show this application.
*
* class MyTask extends Task
* Typically the resources for this class would be defined in the
* MyTask ResourceBundle, @{code resources/MyTask.properties}:
*
* title = My Task
* description = A task of mine for my own purposes.
* startMessage = Starting: working on %s subtasks...
* errorMessage = An unexpected error occurred, skipping subtask
* finishedMessage = Finished: completed %1$s subtasks, %2$s failures
*
*
*
* class MyTaskSubclass extends MyTask {
* }
* # resources/MyTaskSubclass.properties
* title = My Task Subclass
* description = An appropriate description
* # ... all other resources are inherited
*
*
*
* class MyInputBlocker extends InputBlocker {
* BusyIndicatorInputBlocker(Task task) {
* super(task, Task.BlockingScope.WINDOW, myGlassPane);
* }
* protected void block() {
* myFrame.setGlassPane(myGlassPane);
* busyGlassPane.setVisible(true);
* }
* protected void unblock() {
* busyGlassPane.setVisible(false);
* }
* }
* // ...
* myTask.setInputBlocker(new MyInputBlocker(myTask));
*
*
* ApplicationContext.getInstance().getResourceMap(this.getClass(), Task.class)
* . The {@code resourcePrefix} is used to construct
* the resource names for the intial values of the
* {@code title}, {@code description}, and {@code message} Task properties
* and for message {@link java.util.Formatter format} strings.
*
* @param application
* @param resourcePrefix prefix for resource names, can be null
* @see #getResourceMap
* @see #setTitle
* @see #setDescription
* @see #setMessage
* @see #resourceName
* @see ApplicationContext#getResourceMap
* @deprecated
*/
@Deprecated
public Task(Application application, String resourcePrefix) {
this.application = application;
initTask(defaultResourceMap(application), resourcePrefix);
}
/**
* Construct a {@code Task} with an empty ("") resource name
* prefix, whose ResourceMap is the value of
* ApplicationContext.getInstance().getResourceMap(this.getClass(),
* Task.class).
* @param application
*/
public Task(Application application) {
this.application = application;
initTask(defaultResourceMap(application), "");
}
public final Application getApplication() {
return application;
}
public final ApplicationContext getContext() {
return getApplication().getContext();
}
/**
* Returns the TaskService that this Task has been submitted to,
* or null. This property is set when a task is executed by a
* TaskService, cleared when the task is done.
*
* long nSeconds = myTask.getExecutionDuration(TimeUnit.SECONDS);
*
*
* @param unit the time unit of the return value
* @return the length of time this Task has run.
* @see #execute
*/
public long getExecutionDuration(TimeUnit unit) {
long startTime, doneTime, dt;
synchronized (this) {
startTime = this.startTime;
doneTime = this.doneTime;
}
if (startTime == -1L) {
dt = 0L;
} else if (doneTime == -1L) {
dt = System.currentTimeMillis() - startTime;
} else {
dt = doneTime - startTime;
}
return unit.convert(Math.max(0L, dt), TimeUnit.MILLISECONDS);
}
/**
* Return the value of the {@code message} property.
* The default value of this property is the value of the
* {@link #getResourceMap resourceMap's} {@code message} resource.
*
* loadTask.setTitle("Loading photo from http://photos.com/sunset");
* // ...
* loadTask.setMessage("opening connection to photos.com");
* // ...
* loadTask.setMessage("reading thumbnail image file sunset.png");
* // ... etc
*
*
* setMessage(getResourceMap().getString(resourceName(formatResourceKey)));
*
*
* value - min / max - min
*
*
* @param value a value in the range min ... max, inclusive
* @param min the minimum value of the range
* @param max the maximum value of the range
* @see #setProgress(int)
*/
protected final void setProgress(int value, int min, int max) {
if (min >= max) {
throw new IllegalArgumentException("invalid range: min >= max");
}
if ((value < min) || (value > max)) {
throw new IllegalArgumentException("invalid value");
}
float percentage = (float) (value - min) / (float) (max - min);
setProgress(Math.round(percentage * 100.0f));
}
/**
* A convenience method that sets the {@code progress} property to
* percentage * 100.
*
* @param percentage a value in the range 0.0 ... 1.0 inclusive
* @see #setProgress(int)
*/
protected final void setProgress(float percentage) {
if ((percentage < 0.0) || (percentage > 1.0)) {
throw new IllegalArgumentException("invalid percentage");
}
setProgress(Math.round(percentage * 100.0f));
}
/**
* A convenience method that sets the {@code progress} property to the following
* ratio normalized to 0 .. 100.
*
* value - min / max - min
*
*
* @param value a value in the range min ... max, inclusive
* @param min the minimum value of the range
* @param max the maximum value of the range
* @see #setProgress(int)
*/
protected final void setProgress(float value, float min, float max) {
if (min >= max) {
throw new IllegalArgumentException("invalid range: min >= max");
}
if ((value < min) || (value > max)) {
throw new IllegalArgumentException("invalid value");
}
float percentage = (value - min) / (max - min);
setProgress(Math.round(percentage * 100.0f));
}
/**
* Equivalent to {@code getState() == StateValue.PENDING}.
*
*
* Task.BlockingScope.NONETask.BlockingScope.ACTIONTask.BlockingScope.COMPONENTTask.BlockingScope.WINDOWTask.BlockingScope.Application
*
*
* class MyApplication extends SingleFrameApplication {
* @ppOverride protected void startup() {
* View view = getMainView();
* view.setComponent(createMainComponent());
* view.setMenuBar(createMenuBar());
* show(view);
* }
* }
*
*
* resources/
* resources/black1x1.png
*
*
* @author Hans Muller (Hans.Muller@Sun.COM)
*/
public class ApplicationTest
{
public static class SimpleApplication extends WaitForStartupApplication
{
public boolean startupOnEDT;
@Override
protected void startup()
{
startupOnEDT = SwingUtilities.isEventDispatchThread();
super.startup();
}
@Action()
public void simpleAppAction()
{ }
}
@Before
public void methodSetup()
{
SimpleApplication.launchAndWait(SimpleApplication.class);
}
private ApplicationContext getApplicationContext()
{
return Application.getInstance(SimpleApplication.class).getContext();
}
@Test
public void testLaunch()
{
ApplicationContext ac = getApplicationContext();
Application app = ac.getApplication();
boolean isSimpleApp = app instanceof SimpleApplication;
assertTrue("ApplicationContext.getApplication()", isSimpleApp);
Class appClass = ac.getApplicationClass();
assertSame("ApplicationContext.getApplicationClass()", SimpleApplication.class, appClass);
assertTrue("SimpleApplication.startup() ran to completion", ((SimpleApplication) app).isStarted());
assertTrue("SimpleApplication.startup() ran on the EDT", ((SimpleApplication) app).startupOnEDT);
}
@Test
public void testGetResourceMap()
{
ApplicationContext ac = getApplicationContext();
String bundleBaseName = getClass().getPackage().getName() + ".resources.";
/* Check the Application ResourceMap chain */
{
ResourceMap appRM = ac.getResourceMap();
assertNotNull("Application ResourceMap", appRM);
/* Application ResourceMap rm should have a null parent
* and three bundles:
*/
String[] expectedBundleNames = {
bundleBaseName + "SimpleApplication",
bundleBaseName + "WaitForStartupApplication",
bundleBaseName + "Application"
};
String[] actualBundleNames = appRM.getBundleNames().toArray(new String[0]);
assertArrayEquals(expectedBundleNames, actualBundleNames);
}
/* Check the ResourceMap for getClass() */
{
ResourceMap rm = ac.getResourceMap(getClass());
assertNotNull(rm);
assertEquals(bundleBaseName + "ApplicationTest", rm.getBundleNames().get(0));
}
}
/**
* Verify that the platform resource was initialized to "osx" or "default"
* and that it can be reset.
*/
@Test
public void testPlatformResource()
{
ApplicationContext ctx = getApplicationContext();
ResourceManager rm = ctx.getResourceManager();
PlatformType platform = rm.getPlatform();
String osName = System.getProperty("os.name").toLowerCase();
boolean isPlatformSet = false;
for (String ptr : platform.getPatterns()) {
if (osName.startsWith(ptr)) {
isPlatformSet = true;
break;
}
}
assertTrue(isPlatformSet);
try {
ctx.getResourceManager().setPlatform(PlatformType.FREE_BSD);
fail("It is forbidden to change the platform of a resource map.");
} catch (Exception ignore) {
}
String currentPlatform = rm.getResourceMap().getString("currentPlatform");
assertEquals(platform.getName(), currentPlatform);
}
private void checkActionName(String msg, javax.swing.Action action, String expectedValue)
{
String value = (String) (action.getValue(javax.swing.Action.NAME));
assertEquals(msg + ".getValue(javax.swing.Action.NAME)", expectedValue, value);
}
public static class SimpleController
{
@Action()
public void simpleControllerAction()
{ }
}
/**
* Verify that the ActionMap for SimplController.class contains an Action
* for "simpleControllerAction" and a parent ActionMap, defined by
* SimpleControllerApp, that contains "simpleControllerAppAction".
*/
@Test
public void testGetActionMap()
{
SimpleController sc = new SimpleController();
/* There should be four ActionMaps in the parent chain for sc, based on:
* 0 - SimpleController.class
* 1 - SimpleApplication.class
* 1 - WaitForStartupApplication.class
* 2 - Application.class // parent of this one should be null
*/
Class[] actionsClasses = {
SimpleController.class,
SimpleApplication.class,
WaitForStartupApplication.class,
Application.class
};
ApplicationActionMap actionMap = getApplicationContext().getActionMap(sc);
int n = 0;
for (Class actionsClass : actionsClasses)
{
assertNotNull("ActionMap " + actionsClass + " " + n, actionMap);
assertSame("ActionMap actionsClass " + n, actionsClass, actionMap.getActionsClass());
actionMap = (ApplicationActionMap) actionMap.getParent();
}
assertNull("Application actionMap parent", actionMap);
actionMap = getApplicationContext().getActionMap(sc);
String simpleControllerAction = "simpleControllerAction";
String gamString = "Application.getActionMap(simpleController)";
String gscaString = gamString + ".get(\"" + simpleControllerAction + "\")";
javax.swing.Action scAction = actionMap.get(simpleControllerAction);
assertNotNull(gscaString, scAction);
checkActionName(gscaString, scAction, simpleControllerAction);
String simpleAppAction = "simpleAppAction";
String gsaaString = gamString + ".get(\"" + simpleAppAction + "\")";
javax.swing.Action saAction = actionMap.get(simpleAppAction);
assertNotNull(gsaaString, saAction);
checkActionName(gsaaString, saAction, simpleAppAction);
String noSuchAction = "noSuchAction";
String gnsaString = gamString + ".get(\"" + noSuchAction + "\")";
javax.swing.Action nsAction = actionMap.get(noSuchAction);
assertNull(gnsaString, nsAction);
}
/**
* Check the ActionMap returned by ApplicationContext.getActionMap(),
* i.e. the global ApplicationMap.
*/
@Test
public void testGetAppActionMap()
{
/* In this case there should be just three ActionMaps in the
* parent chain:
* 0 - SimpleApplication.class
* 1 - WaitForStartupApplication.class
* 2 - Application.class // parent of this one should be null
*/
Class[] actionsClasses = {
SimpleApplication.class,
WaitForStartupApplication.class,
Application.class
};
ApplicationActionMap actionMap = getApplicationContext().getActionMap();
int n = 0;
for (Class actionsClass : actionsClasses)
{
assertNotNull("ActionMap " + actionsClass + " " + n, actionMap);
assertSame("ActionMap actionsClass " + n, actionsClass, actionMap.getActionsClass());
actionMap = (ApplicationActionMap) actionMap.getParent();
}
assertNull("Application actionMap parent", actionMap);
actionMap = getApplicationContext().getActionMap();
String simpleControllerAction = "simpleControllerAction";
String gamString = "Application.getActionMap()";
String gscaString = gamString + ".get(\"" + simpleControllerAction + "\")";
javax.swing.Action scAction = actionMap.get(simpleControllerAction);
assertNull(gscaString, scAction);
String simpleAppAction = "simpleAppAction";
String gsaaString = gamString + ".get(\"" + simpleAppAction + "\")";
javax.swing.Action saAction = actionMap.get(simpleAppAction);
assertNotNull(gsaaString, saAction);
checkActionName(gsaaString, saAction, simpleAppAction);
}
public static class StatefulController
{
private int n = 0;
@Action()
public void one()
{ n = 1; }
@Action()
public void two()
{ n = 2; }
public int getN() { return n; }
}
private void checkSCActionMap(ApplicationActionMap appAM, Object actionsObject, Class actionsClass)
{
String msg = "ActionMap for " + actionsClass;
assertNotNull(msg, appAM);
assertSame(msg + ".getActionsObject()", actionsObject, appAM.getActionsObject());
assertSame(msg + ".getActionsClass()", actionsClass, appAM.getActionsClass());
assertNotNull(msg + ".getAction(\"one\")", appAM.get("one"));
assertNotNull(msg + ".getAction(\"two\")", appAM.get("two"));
}
/**
* Verify that getActionMap() caches per target actionsObject, not per @Actions
* class.
*/
@Test
public void testGetActionMapPerObject()
{
StatefulController sc1 = new StatefulController();
StatefulController sc2 = new StatefulController();
StatefulController sc3 = new StatefulController();
ApplicationContext ac = getApplicationContext();
ApplicationActionMap am1 = ac.getActionMap(sc1);
ApplicationActionMap am2 = ac.getActionMap(sc2);
ApplicationActionMap am3 = ac.getActionMap(sc3);
checkSCActionMap(am1, sc1, StatefulController.class);
checkSCActionMap(am2, sc2, StatefulController.class);
checkSCActionMap(am3, sc3, StatefulController.class);
String oneActionMapPerObject = "one ActionMap per actionsObject";
assertTrue(oneActionMapPerObject, am1 != am2);
assertTrue(oneActionMapPerObject, am1 != am3);
assertTrue(oneActionMapPerObject, am2 != am3);
ActionEvent event = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, "not used");
am1.get("one").actionPerformed(event);
am2.get("two").actionPerformed(event);
assertEquals("StatefulController.getN(), after calling @Action sc1.one()", 1, sc1.getN());
assertEquals("StatefulController.getN(), after calling @Action sc2.two()", 2, sc2.getN());
assertEquals("StatefulController.getN(), no @Actions called", 0, sc3.getN());
}
public static class ActionMapObject
{
int n;
ActionMapObject(int n) { this.n = n; }
@Action()
public void anAction()
{ n = -1; }
}
/**
* Verify that ActionMaps are GC'd when their target actionsObject is
* no longer referred to and their actions are no longer in use (no
* longer referred to).
*/
@Test
public void testActionMapGC()
{
ApplicationContext ac = getApplicationContext();
List