* if (ref == null || ref.isEmpty ()) {
* CloneableTopComponent c = new CloneableTopComponent (obj);
* ref = c.getReference ();
* }
*
* Instead one can always set ref = Ref.EMPTY and test only if
* ref.isEmpty returns true.
*/
/** Empty clone-sister list.
*/
public static final Ref EMPTY = new Ref();
/** reference with list of components */
private Ref ref;
/** flag that is true for last activated CloneableTopComponent
* in its sisters list
* Fix for IZ#124647 - method selection in navigator focuses to wrong window
*/
private boolean isLastActivated;
/** Create a cloneable top component.
*/
public CloneableTopComponent() {
}
/** Clone the top component and register the clone.
* @return the new component
*/
public final Object clone() {
return cloneComponent();
}
/** Clone the top component and register the clone.
* Simply calls createClonedObject () and registers the component to
* Ref.
*
* @return the new cloneable top component
*/
public final CloneableTopComponent cloneTopComponent() {
CloneableTopComponent top = createClonedObject();
// register the component if it has not been registered before
top.setReference(getReference());
return top;
}
/** Clone the top component and register the clone.
* @return the new component
*/
public final TopComponent cloneComponent() {
return cloneTopComponent();
}
/** Called from {@link #clone} to actually create a new component from this one.
* The default implementation serializes and deserializes the original and
* returns the result.
* Subclasses may leave this as is, assuming they have no special needs for the cloned
* data besides copying it from one object to the other. If they do, the superclass
* method should be called, and the returned object modified appropriately.
* @return a copy of this object
*/
protected CloneableTopComponent createClonedObject() {
try {
// clones the component using serialization
NbMarshalledObject o = new NbMarshalledObject(this);
return (CloneableTopComponent) o.get();
} catch (IOException ex) {
throw new AssertionError(ex);
} catch (ClassNotFoundException ex) {
throw new AssertionError(ex);
}
}
/** Get a list of all components which are clone-sisters of this one.
*
* @return the clone registry for this component's group
*/
public synchronized final Ref getReference() {
if (ref == null) {
ref = new Ref(this);
}
return ref;
}
/** Changes the reference to which this components belongs.
* @param another the new reference this component should belong
*/
public synchronized final void setReference(Ref another) {
if (another == EMPTY) {
throw new IllegalArgumentException(
NbBundle.getBundle(CloneableTopComponent.class).getString("EXC_CannotAssign")
);
}
if (ref != null) {
// Remove from old ref, we are going to belong to 'another' reference.
ref.removeComponent(this);
}
// Register with the new reference.
another.register(this);
// Finally set the field.
ref = another;
}
@Override
protected void componentOpened() {
super.componentOpened();
getReference().register(this);
CloneableOpenSupport cos = getLookup().lookup(CloneableOpenSupport.class);
if (cos != null) {
CloneableOpenSupportRedirector.notifyOpened(cos);
}
}
/** Overrides superclass method, adds unregistering from references.
* @see Ref */
protected void componentClosed() {
super.componentClosed();
if (!isOpened()) {
try {
CloneableOpenSupport cos = getLookup().lookup(CloneableOpenSupport.class);
if (cos != null) {
CloneableOpenSupportRedirector.notifyClosed(cos);
}
} finally {
getReference().unregister(this);
}
}
}
/**
* Unregisters this component from its clone list.
* {@inheritDoc}
*/
public boolean canClose() {
if (!isOpened()) {
return false;
}
return getReference().unregister(this);
}
@SuppressWarnings("deprecation")
public boolean canClose(Workspace workspace, boolean last) {
if (last) {
return getReference().unregister(this);
}
return true;
}
/** Called when the last component in a clone group is closing.
* The default implementation just returns true.
* Subclasses may specify some hooks to run.
* @return true if the component is ready to be
* closed, false to cancel
*/
protected boolean closeLast() {
return true;
}
public void readExternal(ObjectInput oi) throws IOException, ClassNotFoundException {
super.readExternal(oi);
if (serialVersion != 0) {
// since serialVersion > 0
// the reference object is also stored
Ref ref = (Ref) oi.readObject();
if (ref != null) {
setReference(ref);
}
}
}
public void writeExternal(ObjectOutput oo) throws java.io.IOException {
super.writeExternal(oo);
oo.writeObject(ref);
}
private boolean isLastActive(){
return isLastActivated;
}
private void setLastActivated(){
isLastActivated = true;
}
private void unsetLastActivated(){
isLastActivated = false;
}
/** Keeps track of a group of sister clones.
*
* Warning:
* For proper use
* subclasses should have method readResolve () and implement it
* in right way to deal with separate serialization of TopComponent.
*/
public static class Ref implements Serializable {
/** generated Serialized Version UID */
static final long serialVersionUID = 5543148876020730556L;
/** manipulation lock */
private static final Object LOCK = new Object();
/** Set of registered components. */
private transient /*final*/ Settrue if the reference set is empty
*/
public boolean isEmpty() {
synchronized (LOCK) {
return componentSet.isEmpty();
}
}
/** Retrieve an arbitrary component from the set.
* @return some component from the list of registered ones
* @exception NoSuchElementException if the set is empty
* @deprecated Use {@link #getArbitraryComponent} instead.
* It doesn't throw a runtime exception.
*/
public CloneableTopComponent getAnyComponent() {
synchronized (LOCK) {
return componentSet.iterator().next();
}
}
/** Gets arbitrary component from the set. Preferrably returns currently
* active component if found in the set.
* @return arbitratry CloneableTopComponent from the set
* or null if the set is empty
* @since 3.41 */
public CloneableTopComponent getArbitraryComponent() {
TopComponent activated = WindowManager.getDefault().getRegistry().getActivated();
synchronized (LOCK) {
// prefer already active component
if (componentSet.contains(activated)) {
return (CloneableTopComponent) activated;
}
//Fix for IZ#124647 - method selection in navigator focuses to wrong window
CloneableTopComponent result =null;
for( CloneableTopComponent comp : componentSet ){
result = comp;
if ( comp.isLastActive() ){
break;
}
}
return result;
}
}
/** Register new component.
* @param c the component to register
*/
private final void register(CloneableTopComponent c) {
synchronized (LOCK) {
componentSet.add(c);
}
}
/** Unregister the component. If this is the last asks if it is
* allowed to unregister it.
*
* @param c the component to unregister
* @return true if the component agreed to be unregister
*/
private final boolean unregister(CloneableTopComponent c) {
int componentCount;
synchronized (LOCK) {
if (!componentSet.contains(c)) {
return true;
}
componentCount = componentSet.size();
}
if ((componentCount > 1) || c.closeLast()) {
removeComponent(c);
return true;
} else {
return false;
}
}
private void removeComponent(CloneableTopComponent c) {
synchronized (LOCK) {
componentSet.remove(c);
}
}
/** Adds also initializing of componentSet field. */
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
synchronized (LOCK) {
componentSet = new HashSet