ojluni/src/main/java/sun/awt/datatransfer/SunClipboard.java - platform/libcore.git - Git at Google

 /*
  * Copyright (c) 1999, 2006, 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.awt.datatransfer;

 import java.awt.EventQueue;

 import java.awt.datatransfer.Clipboard;
 import java.awt.datatransfer.FlavorTable;
 import java.awt.datatransfer.SystemFlavorMap;
 import java.awt.datatransfer.Transferable;
 import java.awt.datatransfer.ClipboardOwner;
 import java.awt.datatransfer.DataFlavor;
 import java.awt.datatransfer.FlavorListener;
 import java.awt.datatransfer.FlavorEvent;
 import java.awt.datatransfer.UnsupportedFlavorException;

 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;

 import java.util.Iterator;
 import java.util.Set;
 import java.util.HashSet;

 import java.io.IOException;

 import sun.awt.AppContext;
 import sun.awt.PeerEvent;
 import sun.awt.SunToolkit;
 import sun.awt.EventListenerAggregate;


 /**
  * Serves as a common, helper superclass for the Win32 and X11 system
  * Clipboards.
  *
  * @author Danila Sinopalnikov
  * @author Alexander Gerasimov
  *
  * @since 1.3
  */
 public abstract class SunClipboard extends Clipboard
     implements PropertyChangeListener {

     public static final FlavorTable flavorMap =
         (FlavorTable)SystemFlavorMap.getDefaultFlavorMap();

     private AppContext contentsContext = null;

     private final Object CLIPBOARD_FLAVOR_LISTENER_KEY;

     /**
      * A number of <code>FlavorListener</code>s currently registered
      * on this clipboard across all <code>AppContext</code>s.
      */
     private volatile int numberOfFlavorListeners = 0;

     /**
      * A set of <code>DataFlavor</code>s that is available on
      * this clipboard. It is used for tracking changes
      * of <code>DataFlavor</code>s available on this clipboard.
      */
     private volatile Set currentDataFlavors;


     public SunClipboard(String name) {
         super(name);
         CLIPBOARD_FLAVOR_LISTENER_KEY = new StringBuffer(name + "_CLIPBOARD_FLAVOR_LISTENER_KEY");
     }

     public synchronized void setContents(Transferable contents,
                                          ClipboardOwner owner) {
         // 4378007 : Toolkit.getSystemClipboard().setContents(null, null)
         // should throw NPE
         if (contents == null) {
             throw new NullPointerException("contents");
         }

         initContext();

         final ClipboardOwner oldOwner = this.owner;
         final Transferable oldContents = this.contents;

         try {
             this.owner = owner;
             this.contents = new TransferableProxy(contents, true);

             setContentsNative(contents);
         } finally {
             if (oldOwner != null && oldOwner != owner) {
                 EventQueue.invokeLater(new Runnable() {
                     public void run() {
                         oldOwner.lostOwnership(SunClipboard.this, oldContents);
                     }
                 });
             }
         }
     }

     private synchronized void initContext() {
         final AppContext context = AppContext.getAppContext();

         if (contentsContext != context) {
             // Need to synchronize on the AppContext to guarantee that it cannot
             // be disposed after the check, but before the listener is added.
             synchronized (context) {
                 if (context.isDisposed()) {
                     throw new IllegalStateException("Can't set contents from disposed AppContext");
                 }
                 context.addPropertyChangeListener
                     (AppContext.DISPOSED_PROPERTY_NAME, this);
             }
             if (contentsContext != null) {
                 contentsContext.removePropertyChangeListener
                     (AppContext.DISPOSED_PROPERTY_NAME, this);
             }
             contentsContext = context;
         }
     }

     public synchronized Transferable getContents(Object requestor) {
         if (contents != null) {
             return contents;
         }
         return new ClipboardTransferable(this);
     }


     /**
      * @return the contents of this clipboard if it has been set from the same
      *         AppContext as it is currently retrieved or null otherwise
      * @since 1.5
      */
     private synchronized Transferable getContextContents() {
         AppContext context = AppContext.getAppContext();
         return (context == contentsContext) ? contents : null;
     }


     /**
      * @see java.awt.Clipboard#getAvailableDataFlavors
      * @since 1.5
      */
     public DataFlavor[] getAvailableDataFlavors() {
         Transferable cntnts = getContextContents();
         if (cntnts != null) {
             return cntnts.getTransferDataFlavors();
         }

         long[] formats = getClipboardFormatsOpenClose();

         return DataTransferer.getInstance().
             getFlavorsForFormatsAsArray(formats, flavorMap);
     }

     /**
      * @see java.awt.Clipboard#isDataFlavorAvailable
      * @since 1.5
      */
     public boolean isDataFlavorAvailable(DataFlavor flavor) {
         if (flavor == null) {
             throw new NullPointerException("flavor");
         }

         Transferable cntnts = getContextContents();
         if (cntnts != null) {
             return cntnts.isDataFlavorSupported(flavor);
         }

         long[] formats = getClipboardFormatsOpenClose();

         return formatArrayAsDataFlavorSet(formats).contains(flavor);
     }

     /**
      * @see java.awt.Clipboard#getData
      * @since 1.5
      */
     public Object getData(DataFlavor flavor)
         throws UnsupportedFlavorException, IOException {
         if (flavor == null) {
             throw new NullPointerException("flavor");
         }

         Transferable cntnts = getContextContents();
         if (cntnts != null) {
             return cntnts.getTransferData(flavor);
         }

         long format = 0;
         byte[] data = null;
         Transferable localeTransferable = null;

         try {
             openClipboard(null);

             long[] formats = getClipboardFormats();
             Long lFormat = (Long)DataTransferer.getInstance().
                     getFlavorsForFormats(formats, flavorMap).get(flavor);

             if (lFormat == null) {
                 throw new UnsupportedFlavorException(flavor);
             }

             format = lFormat.longValue();
             data = getClipboardData(format);

             if (DataTransferer.getInstance().isLocaleDependentTextFormat(format)) {
                 localeTransferable = createLocaleTransferable(formats);
             }

         } finally {
             closeClipboard();
         }

         return DataTransferer.getInstance().
                 translateBytes(data, flavor, format, localeTransferable);
     }

     /**
      * The clipboard must be opened.
      *
      * @since 1.5
      */
     protected Transferable createLocaleTransferable(long[] formats) throws IOException {
         return null;
     }

     /**
      * @throws IllegalStateException if the clipboard has not been opened
      */
     public void openClipboard(SunClipboard newOwner) {}
     public void closeClipboard() {}

     public abstract long getID();

     public void propertyChange(PropertyChangeEvent evt) {
         if (AppContext.DISPOSED_PROPERTY_NAME.equals(evt.getPropertyName()) &&
             Boolean.TRUE.equals(evt.getNewValue())) {
             final AppContext disposedContext = (AppContext)evt.getSource();
             lostOwnershipLater(disposedContext);
         }
     }

     protected void lostOwnershipImpl() {
         lostOwnershipLater(null);
     }

     /**
      * Clears the clipboard state (contents, owner and contents context) and
      * notifies the current owner that ownership is lost. Does nothing if the
      * argument is not <code>null</code> and is not equal to the current
      * contents context.
      *
      * @param disposedContext the AppContext that is disposed or
      *        <code>null</code> if the ownership is lost because another
      *        application acquired ownership.
      */
     protected void lostOwnershipLater(final AppContext disposedContext) {
         final AppContext context = this.contentsContext;
         if (context == null) {
             return;
         }

         final Runnable runnable = new Runnable() {
                 public void run() {
                     final SunClipboard sunClipboard = SunClipboard.this;
                     ClipboardOwner owner = null;
                     Transferable contents = null;

                     synchronized (sunClipboard) {
                         final AppContext context = sunClipboard.contentsContext;

                         if (context == null) {
                             return;
                         }

                         if (disposedContext == null || context == disposedContext) {
                             owner = sunClipboard.owner;
                             contents = sunClipboard.contents;
                             sunClipboard.contentsContext = null;
                             sunClipboard.owner = null;
                             sunClipboard.contents = null;
                             sunClipboard.clearNativeContext();
                             context.removePropertyChangeListener
                                 (AppContext.DISPOSED_PROPERTY_NAME, sunClipboard);
                         } else {
                             return;
                         }
                     }
                     if (owner != null) {
                         owner.lostOwnership(sunClipboard, contents);
                     }
                 }
             };

         SunToolkit.postEvent(context, new PeerEvent(this, runnable,
                                                     PeerEvent.PRIORITY_EVENT));
     }

     protected abstract void clearNativeContext();

     protected abstract void setContentsNative(Transferable contents);

     /**
      * @since 1.5
      */
     protected long[] getClipboardFormatsOpenClose() {
         try {
             openClipboard(null);
             return getClipboardFormats();
         } finally {
             closeClipboard();
         }
     }

     /**
      * Returns zero-length array (not null) if the number of available formats is zero.
      *
      * @throws IllegalStateException if formats could not be retrieved
      */
     protected abstract long[] getClipboardFormats();

     protected abstract byte[] getClipboardData(long format) throws IOException;


     private static Set formatArrayAsDataFlavorSet(long[] formats) {
         return (formats == null) ? null :
                 DataTransferer.getInstance().
                 getFlavorsForFormatsAsSet(formats, flavorMap);
     }


     public synchronized void addFlavorListener(FlavorListener listener) {
         if (listener == null) {
             return;
         }
         AppContext appContext = AppContext.getAppContext();
         EventListenerAggregate contextFlavorListeners = (EventListenerAggregate)
                 appContext.get(CLIPBOARD_FLAVOR_LISTENER_KEY);
         if (contextFlavorListeners == null) {
             contextFlavorListeners = new EventListenerAggregate(FlavorListener.class);
             appContext.put(CLIPBOARD_FLAVOR_LISTENER_KEY, contextFlavorListeners);
         }
         contextFlavorListeners.add(listener);

         if (numberOfFlavorListeners++ == 0) {
             long[] currentFormats = null;
             try {
                 openClipboard(null);
                 currentFormats = getClipboardFormats();
             } catch (IllegalStateException exc) {
             } finally {
                 closeClipboard();
             }
             currentDataFlavors = formatArrayAsDataFlavorSet(currentFormats);

             registerClipboardViewerChecked();
         }
     }

     public synchronized void removeFlavorListener(FlavorListener listener) {
         if (listener == null) {
             return;
         }
         AppContext appContext = AppContext.getAppContext();
         EventListenerAggregate contextFlavorListeners = (EventListenerAggregate)
                 appContext.get(CLIPBOARD_FLAVOR_LISTENER_KEY);
         if (contextFlavorListeners == null){
             //else we throw NullPointerException, but it is forbidden
             return;
         }
         if (contextFlavorListeners.remove(listener) &&
                 --numberOfFlavorListeners == 0) {
             unregisterClipboardViewerChecked();
             currentDataFlavors = null;
         }
     }

     public synchronized FlavorListener[] getFlavorListeners() {
         EventListenerAggregate contextFlavorListeners = (EventListenerAggregate)
                 AppContext.getAppContext().get(CLIPBOARD_FLAVOR_LISTENER_KEY);
         return contextFlavorListeners == null ? new FlavorListener[0] :
                 (FlavorListener[])contextFlavorListeners.getListenersCopy();
     }

     public boolean areFlavorListenersRegistered() {
         return (numberOfFlavorListeners > 0);
     }

     protected abstract void registerClipboardViewerChecked();

     protected abstract void unregisterClipboardViewerChecked();

     /**
      * Checks change of the <code>DataFlavor</code>s and, if necessary,
      * posts notifications on <code>FlavorEvent</code>s to the
      * AppContexts' EDTs.
      * The parameter <code>formats</code> is null iff we have just
      * failed to get formats available on the clipboard.
      *
      * @param formats data formats that have just been retrieved from
      *        this clipboard
      */
     public void checkChange(long[] formats) {
         Set prevDataFlavors = currentDataFlavors;
         currentDataFlavors = formatArrayAsDataFlavorSet(formats);

         if ((prevDataFlavors != null) && (currentDataFlavors != null) &&
                 prevDataFlavors.equals(currentDataFlavors)) {
             // we've been able to successfully get available on the clipboard
             // DataFlavors this and previous time and they are coincident;
             // don't notify
             return;
         }

         class SunFlavorChangeNotifier implements Runnable {
             private final FlavorListener flavorListener;

             SunFlavorChangeNotifier(FlavorListener flavorListener) {
                 this.flavorListener = flavorListener;
             }

             public void run() {
                 if (flavorListener != null) {
                     flavorListener.flavorsChanged(new FlavorEvent(SunClipboard.this));
                 }
             }
         };

         for (Iterator it = AppContext.getAppContexts().iterator(); it.hasNext();) {
             AppContext appContext = (AppContext)it.next();
             if (appContext == null || appContext.isDisposed()) {
                 continue;
             }
             EventListenerAggregate flavorListeners = (EventListenerAggregate)
                     appContext.get(CLIPBOARD_FLAVOR_LISTENER_KEY);
             if (flavorListeners != null) {
                 FlavorListener[] flavorListenerArray =
                         (FlavorListener[])flavorListeners.getListenersInternal();
                 for (int i = 0; i < flavorListenerArray.length; i++) {
                     SunToolkit.postEvent(appContext, new PeerEvent(this,
                             new SunFlavorChangeNotifier(flavorListenerArray[i]),
                             PeerEvent.PRIORITY_EVENT));
                 }
             }
         }
     }

 }
	/*
	* Copyright (c) 1999, 2006, 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.awt.datatransfer;

	import java.awt.EventQueue;

	import java.awt.datatransfer.Clipboard;
	import java.awt.datatransfer.FlavorTable;
	import java.awt.datatransfer.SystemFlavorMap;
	import java.awt.datatransfer.Transferable;
	import java.awt.datatransfer.ClipboardOwner;
	import java.awt.datatransfer.DataFlavor;
	import java.awt.datatransfer.FlavorListener;
	import java.awt.datatransfer.FlavorEvent;
	import java.awt.datatransfer.UnsupportedFlavorException;

	import java.beans.PropertyChangeEvent;
	import java.beans.PropertyChangeListener;

	import java.util.Iterator;
	import java.util.Set;
	import java.util.HashSet;

	import java.io.IOException;

	import sun.awt.AppContext;
	import sun.awt.PeerEvent;
	import sun.awt.SunToolkit;
	import sun.awt.EventListenerAggregate;


	/**
	* Serves as a common, helper superclass for the Win32 and X11 system
	* Clipboards.
	*
	* @author Danila Sinopalnikov
	* @author Alexander Gerasimov
	*
	* @since 1.3
	*/
	public abstract class SunClipboard extends Clipboard
	implements PropertyChangeListener {

	public static final FlavorTable flavorMap =
	(FlavorTable)SystemFlavorMap.getDefaultFlavorMap();

	private AppContext contentsContext = null;

	private final Object CLIPBOARD_FLAVOR_LISTENER_KEY;

	/**
	* A number of <code>FlavorListener</code>s currently registered
	* on this clipboard across all <code>AppContext</code>s.
	*/
	private volatile int numberOfFlavorListeners = 0;

	/**
	* A set of <code>DataFlavor</code>s that is available on
	* this clipboard. It is used for tracking changes
	* of <code>DataFlavor</code>s available on this clipboard.
	*/
	private volatile Set currentDataFlavors;


	public SunClipboard(String name) {
	super(name);
	CLIPBOARD_FLAVOR_LISTENER_KEY = new StringBuffer(name + "_CLIPBOARD_FLAVOR_LISTENER_KEY");
	}

	public synchronized void setContents(Transferable contents,
	ClipboardOwner owner) {
	// 4378007 : Toolkit.getSystemClipboard().setContents(null, null)
	// should throw NPE
	if (contents == null) {
	throw new NullPointerException("contents");
	}

	initContext();

	final ClipboardOwner oldOwner = this.owner;
	final Transferable oldContents = this.contents;

	try {
	this.owner = owner;
	this.contents = new TransferableProxy(contents, true);

	setContentsNative(contents);
	} finally {
	if (oldOwner != null && oldOwner != owner) {
	EventQueue.invokeLater(new Runnable() {
	public void run() {
	oldOwner.lostOwnership(SunClipboard.this, oldContents);
	}
	});
	}
	}
	}

	private synchronized void initContext() {
	final AppContext context = AppContext.getAppContext();

	if (contentsContext != context) {
	// Need to synchronize on the AppContext to guarantee that it cannot
	// be disposed after the check, but before the listener is added.
	synchronized (context) {
	if (context.isDisposed()) {
	throw new IllegalStateException("Can't set contents from disposed AppContext");
	}
	context.addPropertyChangeListener
	(AppContext.DISPOSED_PROPERTY_NAME, this);
	}
	if (contentsContext != null) {
	contentsContext.removePropertyChangeListener
	(AppContext.DISPOSED_PROPERTY_NAME, this);
	}
	contentsContext = context;
	}
	}

	public synchronized Transferable getContents(Object requestor) {
	if (contents != null) {
	return contents;
	}
	return new ClipboardTransferable(this);
	}


	/**
	* @return the contents of this clipboard if it has been set from the same
	* AppContext as it is currently retrieved or null otherwise
	* @since 1.5
	*/
	private synchronized Transferable getContextContents() {
	AppContext context = AppContext.getAppContext();
	return (context == contentsContext) ? contents : null;
	}


	/**
	* @see java.awt.Clipboard#getAvailableDataFlavors
	* @since 1.5
	*/
	public DataFlavor[] getAvailableDataFlavors() {
	Transferable cntnts = getContextContents();
	if (cntnts != null) {
	return cntnts.getTransferDataFlavors();
	}

	long[] formats = getClipboardFormatsOpenClose();

	return DataTransferer.getInstance().
	getFlavorsForFormatsAsArray(formats, flavorMap);
	}

	/**
	* @see java.awt.Clipboard#isDataFlavorAvailable
	* @since 1.5
	*/
	public boolean isDataFlavorAvailable(DataFlavor flavor) {
	if (flavor == null) {
	throw new NullPointerException("flavor");
	}

	Transferable cntnts = getContextContents();
	if (cntnts != null) {
	return cntnts.isDataFlavorSupported(flavor);
	}

	long[] formats = getClipboardFormatsOpenClose();

	return formatArrayAsDataFlavorSet(formats).contains(flavor);
	}

	/**
	* @see java.awt.Clipboard#getData
	* @since 1.5
	*/
	public Object getData(DataFlavor flavor)
	throws UnsupportedFlavorException, IOException {
	if (flavor == null) {
	throw new NullPointerException("flavor");
	}

	Transferable cntnts = getContextContents();
	if (cntnts != null) {
	return cntnts.getTransferData(flavor);
	}

	long format = 0;
	byte[] data = null;
	Transferable localeTransferable = null;

	try {
	openClipboard(null);

	long[] formats = getClipboardFormats();
	Long lFormat = (Long)DataTransferer.getInstance().
	getFlavorsForFormats(formats, flavorMap).get(flavor);

	if (lFormat == null) {
	throw new UnsupportedFlavorException(flavor);
	}

	format = lFormat.longValue();
	data = getClipboardData(format);

	if (DataTransferer.getInstance().isLocaleDependentTextFormat(format)) {
	localeTransferable = createLocaleTransferable(formats);
	}

	} finally {
	closeClipboard();
	}

	return DataTransferer.getInstance().
	translateBytes(data, flavor, format, localeTransferable);
	}

	/**
	* The clipboard must be opened.
	*
	* @since 1.5
	*/
	protected Transferable createLocaleTransferable(long[] formats) throws IOException {
	return null;
	}

	/**
	* @throws IllegalStateException if the clipboard has not been opened
	*/
	public void openClipboard(SunClipboard newOwner) {}
	public void closeClipboard() {}

	public abstract long getID();

	public void propertyChange(PropertyChangeEvent evt) {
	if (AppContext.DISPOSED_PROPERTY_NAME.equals(evt.getPropertyName()) &&
	Boolean.TRUE.equals(evt.getNewValue())) {
	final AppContext disposedContext = (AppContext)evt.getSource();
	lostOwnershipLater(disposedContext);
	}
	}

	protected void lostOwnershipImpl() {
	lostOwnershipLater(null);
	}

	/**
	* Clears the clipboard state (contents, owner and contents context) and
	* notifies the current owner that ownership is lost. Does nothing if the
	* argument is not <code>null</code> and is not equal to the current
	* contents context.
	*
	* @param disposedContext the AppContext that is disposed or
	* <code>null</code> if the ownership is lost because another
	* application acquired ownership.
	*/
	protected void lostOwnershipLater(final AppContext disposedContext) {
	final AppContext context = this.contentsContext;
	if (context == null) {
	return;
	}

	final Runnable runnable = new Runnable() {
	public void run() {
	final SunClipboard sunClipboard = SunClipboard.this;
	ClipboardOwner owner = null;
	Transferable contents = null;

	synchronized (sunClipboard) {
	final AppContext context = sunClipboard.contentsContext;

	if (context == null) {
	return;
	}

	if (disposedContext == null \|\| context == disposedContext) {
	owner = sunClipboard.owner;
	contents = sunClipboard.contents;
	sunClipboard.contentsContext = null;
	sunClipboard.owner = null;
	sunClipboard.contents = null;
	sunClipboard.clearNativeContext();
	context.removePropertyChangeListener
	(AppContext.DISPOSED_PROPERTY_NAME, sunClipboard);
	} else {
	return;
	}
	}
	if (owner != null) {
	owner.lostOwnership(sunClipboard, contents);
	}
	}
	};

	SunToolkit.postEvent(context, new PeerEvent(this, runnable,
	PeerEvent.PRIORITY_EVENT));
	}

	protected abstract void clearNativeContext();

	protected abstract void setContentsNative(Transferable contents);

	/**
	* @since 1.5
	*/
	protected long[] getClipboardFormatsOpenClose() {
	try {
	openClipboard(null);
	return getClipboardFormats();
	} finally {
	closeClipboard();
	}
	}

	/**
	* Returns zero-length array (not null) if the number of available formats is zero.
	*
	* @throws IllegalStateException if formats could not be retrieved
	*/
	protected abstract long[] getClipboardFormats();

	protected abstract byte[] getClipboardData(long format) throws IOException;


	private static Set formatArrayAsDataFlavorSet(long[] formats) {
	return (formats == null) ? null :
	DataTransferer.getInstance().
	getFlavorsForFormatsAsSet(formats, flavorMap);
	}


	public synchronized void addFlavorListener(FlavorListener listener) {
	if (listener == null) {
	return;
	}
	AppContext appContext = AppContext.getAppContext();
	EventListenerAggregate contextFlavorListeners = (EventListenerAggregate)
	appContext.get(CLIPBOARD_FLAVOR_LISTENER_KEY);
	if (contextFlavorListeners == null) {
	contextFlavorListeners = new EventListenerAggregate(FlavorListener.class);
	appContext.put(CLIPBOARD_FLAVOR_LISTENER_KEY, contextFlavorListeners);
	}
	contextFlavorListeners.add(listener);

	if (numberOfFlavorListeners++ == 0) {
	long[] currentFormats = null;
	try {
	openClipboard(null);
	currentFormats = getClipboardFormats();
	} catch (IllegalStateException exc) {
	} finally {
	closeClipboard();
	}
	currentDataFlavors = formatArrayAsDataFlavorSet(currentFormats);

	registerClipboardViewerChecked();
	}
	}

	public synchronized void removeFlavorListener(FlavorListener listener) {
	if (listener == null) {
	return;
	}
	AppContext appContext = AppContext.getAppContext();
	EventListenerAggregate contextFlavorListeners = (EventListenerAggregate)
	appContext.get(CLIPBOARD_FLAVOR_LISTENER_KEY);
	if (contextFlavorListeners == null){
	//else we throw NullPointerException, but it is forbidden
	return;
	}
	if (contextFlavorListeners.remove(listener) &&
	--numberOfFlavorListeners == 0) {
	unregisterClipboardViewerChecked();
	currentDataFlavors = null;
	}
	}

	public synchronized FlavorListener[] getFlavorListeners() {
	EventListenerAggregate contextFlavorListeners = (EventListenerAggregate)
	AppContext.getAppContext().get(CLIPBOARD_FLAVOR_LISTENER_KEY);
	return contextFlavorListeners == null ? new FlavorListener[0] :
	(FlavorListener[])contextFlavorListeners.getListenersCopy();
	}

	public boolean areFlavorListenersRegistered() {
	return (numberOfFlavorListeners > 0);
	}

	protected abstract void registerClipboardViewerChecked();

	protected abstract void unregisterClipboardViewerChecked();

	/**
	* Checks change of the <code>DataFlavor</code>s and, if necessary,
	* posts notifications on <code>FlavorEvent</code>s to the
	* AppContexts' EDTs.
	* The parameter <code>formats</code> is null iff we have just
	* failed to get formats available on the clipboard.
	*
	* @param formats data formats that have just been retrieved from
	* this clipboard
	*/
	public void checkChange(long[] formats) {
	Set prevDataFlavors = currentDataFlavors;
	currentDataFlavors = formatArrayAsDataFlavorSet(formats);

	if ((prevDataFlavors != null) && (currentDataFlavors != null) &&
	prevDataFlavors.equals(currentDataFlavors)) {
	// we've been able to successfully get available on the clipboard
	// DataFlavors this and previous time and they are coincident;
	// don't notify
	return;
	}

	class SunFlavorChangeNotifier implements Runnable {
	private final FlavorListener flavorListener;

	SunFlavorChangeNotifier(FlavorListener flavorListener) {
	this.flavorListener = flavorListener;
	}

	public void run() {
	if (flavorListener != null) {
	flavorListener.flavorsChanged(new FlavorEvent(SunClipboard.this));
	}
	}
	};

	for (Iterator it = AppContext.getAppContexts().iterator(); it.hasNext();) {
	AppContext appContext = (AppContext)it.next();
	if (appContext == null \|\| appContext.isDisposed()) {
	continue;
	}
	EventListenerAggregate flavorListeners = (EventListenerAggregate)
	appContext.get(CLIPBOARD_FLAVOR_LISTENER_KEY);
	if (flavorListeners != null) {
	FlavorListener[] flavorListenerArray =
	(FlavorListener[])flavorListeners.getListenersInternal();
	for (int i = 0; i < flavorListenerArray.length; i++) {
	SunToolkit.postEvent(appContext, new PeerEvent(this,
	new SunFlavorChangeNotifier(flavorListenerArray[i]),
	PeerEvent.PRIORITY_EVENT));
	}
	}
	}
	}

	}