WorkspaceSwitchListenerSupport.java

/*
 * $Id: WorkspaceSwitchListenerSupport.java,v 1.2 2006/09/25 08:52:36 acaproni Exp $
 *
 * $Date: 2006/09/25 08:52:36 $
 * $Revision: 1.2 $
 * $Author: acaproni $
 *
 * Copyright CERN, All Rights Reserved.
 */

package cern.gp.windows;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import org.openide.util.WeakListener;
import org.openide.windows.WindowManager;
import org.openide.windows.Workspace;

/**
 * A helper class to listen to workspace switches.
 * It listens to the Workspace changes and notifies the appropriate xxEntered and xxExited methods .
 * The user has to write a sub-class that overrides the methods s/he is interested in. For instance,
 * if a program wants to be informed any time a workspace is exited, s/he will override the method
 * workspaceExited(). Or, as another example, if a window wants to be informed whenever its own
 * Workspace is entered, it will use the constructor WorkspaceSwitchListenerSupport(Workspace) and
 * override the method myWorkspaceEntered().
 *
 * @author  Vito Baggiolini
 * @version $Revision: 1.2 $ $Date: 2006/09/25 08:52:36 $
 */
public class WorkspaceSwitchListenerSupport implements PropertyChangeListener {
  private final Workspace myWorkspace;
  private final boolean mineOnly;
  // a boolean to keep track whether we are already listening
  private boolean listening;
  private final Object listeningLock = new Object(); // the lock to synchronize access to stop/startListening
  
  /**
   * constructor to be used if you want to be informed about which workspace is
   * being entered. This constructor will only invoke the methods workspaceEntered/Exited
   */
  protected WorkspaceSwitchListenerSupport() {
    this(null, false);
  }
  
  /**
   * constructor to be used if you want to be informed about a specific workspace.
   * if this constructor is used and mineOnly==false all four Entered/Exited methods will be called;
   * if mineOnly == true, only myWorkspaceEntered/Exited will be called
   * @param myWorkspace the workspace for which entering and exiting is monitored
   * @param whether only my workspace shall be monitored, if true, the methodsworkspaceEntered/Exited
   * will not be invoked.
   */
  protected WorkspaceSwitchListenerSupport(Workspace myWorkspace, boolean mineOnly) {
    this.myWorkspace = myWorkspace;
    this.mineOnly = mineOnly;
    startListening();
  }
  
  /**
   * tell the workspace listener to stop listening.
   * This method is thread safe with regards to its counterpart
   * You don't <em>have</em> to call this in the end, as we use a weaklistener
   * @see #startListening
   */
  public void stopListening() {
    if (listening) {
      synchronized (listeningLock) {
        if (listening) { // double-check condition          
          WindowManager.getDefault().removePropertyChangeListener(this);
          listening = !listening;
        }
      }
    }
  }
  /**
   * tell this object to start listening again. This method is called in the constructor.
   * It is not necessary (but not harmful either) to call this menthod again even if we are
   * already listening. Precautions are taken to avoid adding a second listener.
   * This method is thread safe with regards to its counterpart
   * @see #stopListening
   */
  public void startListening() {
    if (!listening) {
      synchronized(listeningLock) {
        if (!listening) { // double-check condition
          PropertyChangeListener propL = WeakListener.propertyChange(this, WindowManager.getDefault());
          
          WindowManager.getDefault().addPropertyChangeListener(propL);
          listening = !listening;
        }
      }
    }
  }
  
  public void propertyChange(PropertyChangeEvent pce) {
    if (!WindowManager.PROP_CURRENT_WORKSPACE.equals(pce.getPropertyName())) { return; }
    if (!mineOnly) {
      workspaceExited((Workspace)pce.getOldValue());
      workspaceEntered((Workspace)pce.getNewValue());
    }
    if (myWorkspace != null) {
      if (myWorkspace == pce.getOldValue()) {
        myWorkspaceExited();
      } else if (myWorkspace == pce.getNewValue()) {
        myWorkspaceEntered();
      }
    }
  }
  protected void workspaceEntered(Workspace ws) {}
  protected void workspaceExited(Workspace ws) {}
  protected void myWorkspaceEntered() {}
  protected void myWorkspaceExited() {}
}