/* * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */package sun.java2d;import sun.java2d.StateTrackable.State;import static sun.java2d.StateTrackable.State.*;/** * This class provides a basic pre-packaged implementation of the * complete {@link StateTrackable} interface with implementations * of the required methods in the interface and methods to manage * transitions in the state of the object. * Classes which wish to implement StateTrackable could create an * instance of this class and delegate all of their implementations * for {@code StateTrackable} methods to the corresponding methods * of this class. */public final class StateTrackableDelegate implements StateTrackable { /** * The {@code UNTRACKABLE_DELEGATE} provides an implementation * of the StateTrackable interface that is permanently in the * {@link State#UNTRACKABLE UNTRACKABLE} state. */ public final static StateTrackableDelegate UNTRACKABLE_DELEGATE = new StateTrackableDelegate(UNTRACKABLE); /** * The {@code IMMUTABLE_DELEGATE} provides an implementation * of the StateTrackable interface that is permanently in the * {@link State#IMMUTABLE IMMUTABLE} state. */ public final static StateTrackableDelegate IMMUTABLE_DELEGATE = new StateTrackableDelegate(IMMUTABLE); /** * Returns a {@code StateTrackableDelegate} instance with the * specified initial {@link State State}. * If the specified {@code State} is * {@link State#UNTRACKABLE UNTRACKABLE} or * {@link State#IMMUTABLE IMMUTABLE} * then the approprirate static instance * {@link #UNTRACKABLE_DELEGATE} or {@link #IMMUTABLE_DELEGATE} * is returned. */ public static StateTrackableDelegate createInstance(State state) { switch (state) { case UNTRACKABLE: return UNTRACKABLE_DELEGATE; case STABLE: return new StateTrackableDelegate(STABLE); case DYNAMIC: return new StateTrackableDelegate(DYNAMIC); case IMMUTABLE: return IMMUTABLE_DELEGATE; default: throw new InternalError("unknown state"); } } private State theState; StateTracker theTracker; // package private for easy access from tracker private int numDynamicAgents; /** * Constructs a StateTrackableDelegate object with the specified * initial State. */ private StateTrackableDelegate(State state) { this.theState = state; } /** * @inheritDoc * @since 1.7 */ public State getState() { return theState; } /** * @inheritDoc * @since 1.7 */ public synchronized StateTracker getStateTracker() { StateTracker st = theTracker; if (st == null) { switch (theState) { case IMMUTABLE: st = StateTracker.ALWAYS_CURRENT; break; case STABLE: st = new StateTracker() { public boolean isCurrent() { return (theTracker == this); } }; break; case DYNAMIC: // We return the NEVER_CURRENT tracker, but that is // just temporary while we are in the DYNAMIC state. // NO BREAK case UNTRACKABLE: st = StateTracker.NEVER_CURRENT; break; } theTracker = st; } return st; } /** * This method provides an easy way for delegating classes to * change the overall {@link State State} of the delegate to * {@link State#IMMUTABLE IMMUTABLE}. * @throws IllegalStateException if the current state is * {@link State#UNTRACKABLE UNTRACKABLE} * @see #setUntrackable * @since 1.7 */ public synchronized void setImmutable() { if (theState == UNTRACKABLE || theState == DYNAMIC) { throw new IllegalStateException("UNTRACKABLE or DYNAMIC "+ "objects cannot become IMMUTABLE"); } theState = IMMUTABLE; theTracker = null; } /** * This method provides an easy way for delegating classes to * change the overall {@link State State} of the delegate to * {@link State#UNTRACKABLE UNTRACKABLE}. * This method is typically called when references to the * internal data buffers have been made public. * @throws IllegalStateException if the current state is * {@link State#IMMUTABLE IMMUTABLE} * @see #setImmutable * @since 1.7 */ public synchronized void setUntrackable() { if (theState == IMMUTABLE) { throw new IllegalStateException("IMMUTABLE objects cannot "+ "become UNTRACKABLE"); } theState = UNTRACKABLE; theTracker = null; } /** * This method provides an easy way for delegating classes to * manage temporarily setting the overall {@link State State} * of the delegate to {@link State#DYNAMIC DYNAMIC} * during well-defined time frames of dynamic pixel updating. * This method should be called once before each flow of control * that might dynamically update the pixels in an uncontrolled * or unpredictable fashion. * <p> * The companion method {@link #removeDynamicAgent} method should * also be called once after each such flow of control has ended. * Failing to call the remove method will result in this object * permanently becoming {@link State#DYNAMIC DYNAMIC} * and therefore effectively untrackable. * <p> * This method will only change the {@link State State} of the * delegate if it is currently {@link State#STABLE STABLE}. * * @throws IllegalStateException if the current state is * {@link State#IMMUTABLE IMMUTABLE} * @since 1.7 */ public synchronized void addDynamicAgent() { if (theState == IMMUTABLE) { throw new IllegalStateException("Cannot change state from "+ "IMMUTABLE"); } ++numDynamicAgents; if (theState == STABLE) { theState = DYNAMIC; theTracker = null; } } /** * This method provides an easy way for delegating classes to * manage restoring the overall {@link State State} of the * delegate back to {@link State#STABLE STABLE} * after a well-defined time frame of dynamic pixel updating. * This method should be called once after each flow of control * that might dynamically update the pixels in an uncontrolled * or unpredictable fashion has ended. * <p> * The companion method {@link #addDynamicAgent} method should * have been called at some point before each such flow of * control began. * If this method is called without having previously called * the add method, the {@link State State} of this object * will become unreliable. * <p> * This method will only change the {@link State State} of the * delegate if the number of outstanding dynamic agents has * gone to 0 and it is currently * {@link State#DYNAMIC DYNAMIC}. * * @since 1.7 */ protected synchronized void removeDynamicAgent() { if (--numDynamicAgents == 0 && theState == DYNAMIC) { theState = STABLE; theTracker = null; } } /** * This method provides an easy way for delegating classes to * indicate that the contents have changed. * This method will invalidate outstanding StateTracker objects * so that any other agents which maintain cached information * about the pixels will know to refresh their cached copies. * This method should be called after every modification to * the data, such as any calls to any of the setElem methods. * <p> * Note that, for efficiency, this method does not check the * {@link State State} of the object to see if it is compatible * with being marked dirty * (i.e. not {@link State#IMMUTABLE IMMUTABLE}). * It is up to the callers to enforce the fact that an * {@code IMMUTABLE} delegate is never modified. * @since 1.7 */ public final void markDirty() { theTracker = null; }}
/*
* Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.java2d;
import sun.java2d.StateTrackable.State;
import static sun.java2d.StateTrackable.State.*;
/**
* This class provides a basic pre-packaged implementation of the
* complete {@link StateTrackable} interface with implementations
* of the required methods in the interface and methods to manage
* transitions in the state of the object.
* Classes which wish to implement StateTrackable could create an
* instance of this class and delegate all of their implementations
* for {@code StateTrackable} methods to the corresponding methods
* of this class.
*/
public final class StateTrackableDelegate implements StateTrackable {
/**
* The {@code UNTRACKABLE_DELEGATE} provides an implementation
* of the StateTrackable interface that is permanently in the
* {@link State#UNTRACKABLE UNTRACKABLE} state.
*/
public final static StateTrackableDelegate UNTRACKABLE_DELEGATE =
new StateTrackableDelegate(UNTRACKABLE);
/**
* The {@code IMMUTABLE_DELEGATE} provides an implementation
* of the StateTrackable interface that is permanently in the
* {@link State#IMMUTABLE IMMUTABLE} state.
*/
public final static StateTrackableDelegate IMMUTABLE_DELEGATE =
new StateTrackableDelegate(IMMUTABLE);
/**
* Returns a {@code StateTrackableDelegate} instance with the
* specified initial {@link State State}.
* If the specified {@code State} is
* {@link State#UNTRACKABLE UNTRACKABLE} or
* {@link State#IMMUTABLE IMMUTABLE}
* then the approprirate static instance
* {@link #UNTRACKABLE_DELEGATE} or {@link #IMMUTABLE_DELEGATE}
* is returned.
*/
public static StateTrackableDelegate createInstance(State state) {
switch (state) {
case UNTRACKABLE:
return UNTRACKABLE_DELEGATE;
case STABLE:
return new StateTrackableDelegate(STABLE);
case DYNAMIC:
return new StateTrackableDelegate(DYNAMIC);
case IMMUTABLE:
return IMMUTABLE_DELEGATE;
default:
throw new InternalError("unknown state");
}
}
private State theState;
StateTracker theTracker; // package private for easy access from tracker
private int numDynamicAgents;
/**
* Constructs a StateTrackableDelegate object with the specified
* initial State.
*/
private StateTrackableDelegate(State state) {
this.theState = state;
}
/**
* @inheritDoc
* @since 1.7
*/
public State getState() {
return theState;
}
/**
* @inheritDoc
* @since 1.7
*/
public synchronized StateTracker getStateTracker() {
StateTracker st = theTracker;
if (st == null) {
switch (theState) {
case IMMUTABLE:
st = StateTracker.ALWAYS_CURRENT;
break;
case STABLE:
st = new StateTracker() {
public boolean isCurrent() {
return (theTracker == this);
}
};
break;
case DYNAMIC:
// We return the NEVER_CURRENT tracker, but that is
// just temporary while we are in the DYNAMIC state.
// NO BREAK
case UNTRACKABLE:
st = StateTracker.NEVER_CURRENT;
break;
}
theTracker = st;
}
return st;
}
/**
* This method provides an easy way for delegating classes to
* change the overall {@link State State} of the delegate to
* {@link State#IMMUTABLE IMMUTABLE}.
* @throws IllegalStateException if the current state is
* {@link State#UNTRACKABLE UNTRACKABLE}
* @see #setUntrackable
* @since 1.7
*/
public synchronized void setImmutable() {
if (theState == UNTRACKABLE || theState == DYNAMIC) {
throw new IllegalStateException("UNTRACKABLE or DYNAMIC "+
"objects cannot become IMMUTABLE");
}
theState = IMMUTABLE;
theTracker = null;
}
/**
* This method provides an easy way for delegating classes to
* change the overall {@link State State} of the delegate to
* {@link State#UNTRACKABLE UNTRACKABLE}.
* This method is typically called when references to the
* internal data buffers have been made public.
* @throws IllegalStateException if the current state is
* {@link State#IMMUTABLE IMMUTABLE}
* @see #setImmutable
* @since 1.7
*/
public synchronized void setUntrackable() {
if (theState == IMMUTABLE) {
throw new IllegalStateException("IMMUTABLE objects cannot "+
"become UNTRACKABLE");
}
theState = UNTRACKABLE;
theTracker = null;
}
/**
* This method provides an easy way for delegating classes to
* manage temporarily setting the overall {@link State State}
* of the delegate to {@link State#DYNAMIC DYNAMIC}
* during well-defined time frames of dynamic pixel updating.
* This method should be called once before each flow of control
* that might dynamically update the pixels in an uncontrolled
* or unpredictable fashion.
* <p>
* The companion method {@link #removeDynamicAgent} method should
* also be called once after each such flow of control has ended.
* Failing to call the remove method will result in this object
* permanently becoming {@link State#DYNAMIC DYNAMIC}
* and therefore effectively untrackable.
* <p>
* This method will only change the {@link State State} of the
* delegate if it is currently {@link State#STABLE STABLE}.
*
* @throws IllegalStateException if the current state is
* {@link State#IMMUTABLE IMMUTABLE}
* @since 1.7
*/
public synchronized void addDynamicAgent() {
if (theState == IMMUTABLE) {
throw new IllegalStateException("Cannot change state from "+
"IMMUTABLE");
}
++numDynamicAgents;
if (theState == STABLE) {
theState = DYNAMIC;
theTracker = null;
}
}
/**
* This method provides an easy way for delegating classes to
* manage restoring the overall {@link State State} of the
* delegate back to {@link State#STABLE STABLE}
* after a well-defined time frame of dynamic pixel updating.
* This method should be called once after each flow of control
* that might dynamically update the pixels in an uncontrolled
* or unpredictable fashion has ended.
* <p>
* The companion method {@link #addDynamicAgent} method should
* have been called at some point before each such flow of
* control began.
* If this method is called without having previously called
* the add method, the {@link State State} of this object
* will become unreliable.
* <p>
* This method will only change the {@link State State} of the
* delegate if the number of outstanding dynamic agents has
* gone to 0 and it is currently
* {@link State#DYNAMIC DYNAMIC}.
*
* @since 1.7
*/
protected synchronized void removeDynamicAgent() {
if (--numDynamicAgents == 0 && theState == DYNAMIC) {
theState = STABLE;
theTracker = null;
}
}
/**
* This method provides an easy way for delegating classes to
* indicate that the contents have changed.
* This method will invalidate outstanding StateTracker objects
* so that any other agents which maintain cached information
* about the pixels will know to refresh their cached copies.
* This method should be called after every modification to
* the data, such as any calls to any of the setElem methods.
* <p>
* Note that, for efficiency, this method does not check the
* {@link State State} of the object to see if it is compatible
* with being marked dirty
* (i.e. not {@link State#IMMUTABLE IMMUTABLE}).
* It is up to the callers to enforce the fact that an
* {@code IMMUTABLE} delegate is never modified.
* @since 1.7
*/
public final void markDirty() {
theTracker = null;
}
}