257 lines
9.4 KiB
Java
257 lines
9.4 KiB
Java
/*
|
|
* 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;
|
|
}
|
|
}
|