5100701: Toolkit.getLockingKeyState() does not work on XToolkit, but works on Motif
Summary: Does not work on Motif but works on XToolkit now; implemented using XQueryPointer.
Reviewed-by: anthony
/*
* Copyright 2003-2008 Sun Microsystems, Inc. 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. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package sun.awt.X11;
import java.awt.datatransfer.Transferable;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Hashtable;
import java.util.Map;
import sun.awt.AppContext;
import sun.awt.SunToolkit;
import sun.awt.UNIXToolkit;
import sun.awt.datatransfer.DataTransferer;
/**
* A class which interfaces with the X11 selection service.
*/
public final class XSelection {
/* Maps atoms to XSelection instances. */
private static final Hashtable<XAtom, XSelection> table = new Hashtable<XAtom, XSelection>();
/* Prevents from parallel selection data request processing. */
private static final Object lock = new Object();
/* The property in which the owner should place the requested data. */
private static final XAtom selectionPropertyAtom = XAtom.get("XAWT_SELECTION");
/* The maximal length of the property data. */
public static final long MAX_LENGTH = 1000000;
/*
* The maximum data size for ChangeProperty request.
* 100 is for the structure prepended to the request.
*/
public static final int MAX_PROPERTY_SIZE;
static {
XToolkit.awtLock();
try {
MAX_PROPERTY_SIZE =
(int)(XlibWrapper.XMaxRequestSize(XToolkit.getDisplay()) * 4 - 100);
} finally {
XToolkit.awtUnlock();
}
}
/* The PropertyNotify event handler for incremental data transfer. */
private static final XEventDispatcher incrementalTransferHandler =
new IncrementalTransferHandler();
/* The context for the current request - protected with awtLock. */
private static WindowPropertyGetter propertyGetter = null;
// The orders of the lock acquisition:
// XClipboard -> XSelection -> awtLock.
// lock -> awtLock.
/* The X atom for the underlying selection. */
private final XAtom selectionAtom;
/*
* Owner-related variables - protected with synchronized (this).
*/
/* The contents supplied by the current owner. */
private Transferable contents = null;
/* The format-to-flavor map for the current owner. */
private Map formatMap = null;
/* The formats supported by the current owner was set. */
private long[] formats = null;
/* The AppContext in which the current owner was set. */
private AppContext appContext = null;
// The X server time of the last XConvertSelection() call;
// protected with 'lock' and awtLock.
private static long lastRequestServerTime;
/* The time at which the current owner was set. */
private long ownershipTime = 0;
// True if we are the owner of this selection.
private boolean isOwner;
private OwnershipListener ownershipListener = null;
private final Object stateLock = new Object();
static {
XToolkit.addEventDispatcher(XWindow.getXAWTRootWindow().getWindow(),
new SelectionEventHandler());
}
/*
* Returns the XSelection object for the specified selection atom or
* <code>null</code> if none exists.
*/
static XSelection getSelection(XAtom atom) {
return table.get(atom);
}
/**
* Creates a selection object.
*
* @param atom the selection atom.
* @param clpbrd the corresponding clipoboard
* @exception NullPointerException if atom is <code>null</code>.
*/
public XSelection(XAtom atom) {
if (atom == null) {
throw new NullPointerException("Null atom");
}
selectionAtom = atom;
table.put(selectionAtom, this);
}
public XAtom getSelectionAtom() {
return selectionAtom;
}
public synchronized boolean setOwner(Transferable contents, Map formatMap,
long[] formats, long time)
{
long owner = XWindow.getXAWTRootWindow().getWindow();
long selection = selectionAtom.getAtom();
// ICCCM prescribes that CurrentTime should not be used for SetSelectionOwner.
if (time == XConstants.CurrentTime) {
time = XToolkit.getCurrentServerTime();
}
this.contents = contents;
this.formatMap = formatMap;
this.formats = formats;
this.appContext = AppContext.getAppContext();
this.ownershipTime = time;
XToolkit.awtLock();
try {
XlibWrapper.XSetSelectionOwner(XToolkit.getDisplay(),
selection, owner, time);
if (XlibWrapper.XGetSelectionOwner(XToolkit.getDisplay(),
selection) != owner)
{
reset();
return false;
}
setOwnerProp(true);
return true;
} finally {
XToolkit.awtUnlock();
}
}
/**
* Blocks the current thread till SelectionNotify or PropertyNotify (in case of INCR transfer) arrives.
*/
private static void waitForSelectionNotify(WindowPropertyGetter dataGetter) throws InterruptedException {
long startTime = System.currentTimeMillis();
XToolkit.awtLock();
try {
do {
DataTransferer.getInstance().processDataConversionRequests();
XToolkit.awtLockWait(250);
} while (propertyGetter == dataGetter && System.currentTimeMillis() < startTime + UNIXToolkit.getDatatransferTimeout());
} finally {
XToolkit.awtUnlock();
}
}
/*
* Returns the list of atoms that represent the targets for which an attempt
* to convert the current selection will succeed.
*/
public long[] getTargets(long time) {
if (XToolkit.isToolkitThread()) {
throw new Error("UNIMPLEMENTED");
}
long[] targets = null;
synchronized (lock) {
WindowPropertyGetter targetsGetter =
new WindowPropertyGetter(XWindow.getXAWTRootWindow().getWindow(),
selectionPropertyAtom, 0, MAX_LENGTH,
true, XConstants.AnyPropertyType);
try {
XToolkit.awtLock();
try {
propertyGetter = targetsGetter;
lastRequestServerTime = time;
XlibWrapper.XConvertSelection(XToolkit.getDisplay(),
getSelectionAtom().getAtom(),
XDataTransferer.TARGETS_ATOM.getAtom(),
selectionPropertyAtom.getAtom(),
XWindow.getXAWTRootWindow().getWindow(),
time);
// If the owner doesn't respond within the
// SELECTION_TIMEOUT, we report conversion failure.
try {
waitForSelectionNotify(targetsGetter);
} catch (InterruptedException ie) {
return new long[0];
} finally {
propertyGetter = null;
}
} finally {
XToolkit.awtUnlock();
}
targets = getFormats(targetsGetter);
} finally {
targetsGetter.dispose();
}
}
return targets;
}
static long[] getFormats(WindowPropertyGetter targetsGetter) {
long[] formats = null;
if (targetsGetter.isExecuted() && !targetsGetter.isDisposed() &&
(targetsGetter.getActualType() == XAtom.XA_ATOM ||
targetsGetter.getActualType() == XDataTransferer.TARGETS_ATOM.getAtom()) &&
targetsGetter.getActualFormat() == 32)
{
// we accept property with TARGETS type to be compatible with old jdks
// see 6607163
int count = targetsGetter.getNumberOfItems();
if (count > 0) {
long atoms = targetsGetter.getData();
formats = new long[count];
for (int index = 0; index < count; index++) {
formats[index] =
Native.getLong(atoms+index*XAtom.getAtomSize());
}
}
}
return formats != null ? formats : new long[0];
}
/*
* Requests the selection data in the specified format and returns
* the data provided by the owner.
*/
public byte[] getData(long format, long time) throws IOException {
if (XToolkit.isToolkitThread()) {
throw new Error("UNIMPLEMENTED");
}
byte[] data = null;
synchronized (lock) {
WindowPropertyGetter dataGetter =
new WindowPropertyGetter(XWindow.getXAWTRootWindow().getWindow(),
selectionPropertyAtom, 0, MAX_LENGTH,
false, // don't delete to handle INCR properly.
XConstants.AnyPropertyType);
try {
XToolkit.awtLock();
try {
propertyGetter = dataGetter;
lastRequestServerTime = time;
XlibWrapper.XConvertSelection(XToolkit.getDisplay(),
getSelectionAtom().getAtom(),
format,
selectionPropertyAtom.getAtom(),
XWindow.getXAWTRootWindow().getWindow(),
time);
// If the owner doesn't respond within the
// SELECTION_TIMEOUT, we report conversion failure.
try {
waitForSelectionNotify(dataGetter);
} catch (InterruptedException ie) {
return new byte[0];
} finally {
propertyGetter = null;
}
} finally {
XToolkit.awtUnlock();
}
if (!dataGetter.isExecuted()) {
throw new IOException("Owner timed out");
}
if (dataGetter.isDisposed()) {
throw new IOException("Owner failed to convert data");
}
// Handle incremental transfer.
if (dataGetter.getActualType() ==
XDataTransferer.INCR_ATOM.getAtom()) {
if (dataGetter.getActualFormat() != 32) {
throw new IOException("Unsupported INCR format: " +
dataGetter.getActualFormat());
}
int count = dataGetter.getNumberOfItems();
if (count <= 0) {
throw new IOException("INCR data is missed.");
}
long ptr = dataGetter.getData();
int len = 0;
{
// Following Xt sources use the last element.
long longLength = Native.getLong(ptr, count-1);
if (longLength <= 0) {
return new byte[0];
}
if (longLength > Integer.MAX_VALUE) {
throw new IOException("Can't handle large data block: "
+ longLength + " bytes");
}
len = (int)longLength;
}
dataGetter.dispose();
ByteArrayOutputStream dataStream = new ByteArrayOutputStream(len);
while (true) {
WindowPropertyGetter incrDataGetter =
new WindowPropertyGetter(XWindow.getXAWTRootWindow().getWindow(),
selectionPropertyAtom,
0, MAX_LENGTH, false,
XConstants.AnyPropertyType);
try {
XToolkit.awtLock();
XToolkit.addEventDispatcher(XWindow.getXAWTRootWindow().getWindow(),
incrementalTransferHandler);
propertyGetter = incrDataGetter;
try {
XlibWrapper.XDeleteProperty(XToolkit.getDisplay(),
XWindow.getXAWTRootWindow().getWindow(),
selectionPropertyAtom.getAtom());
// If the owner doesn't respond within the
// SELECTION_TIMEOUT, we terminate incremental
// transfer.
waitForSelectionNotify(incrDataGetter);
} catch (InterruptedException ie) {
break;
} finally {
propertyGetter = null;
XToolkit.removeEventDispatcher(XWindow.getXAWTRootWindow().getWindow(),
incrementalTransferHandler);
XToolkit.awtUnlock();
}
// The owner didn't respond - terminate the transfer.
if (!incrDataGetter.isExecuted()) {
throw new IOException("Owner timed out");
}
if (incrDataGetter.isDisposed()) {
throw new IOException("Owner failed to convert data");
}
if (incrDataGetter.getActualFormat() != 8) {
throw new IOException("Unsupported data format: " +
incrDataGetter.getActualFormat());
}
count = incrDataGetter.getNumberOfItems();
if (count == 0) {
break;
}
if (count > 0) {
ptr = incrDataGetter.getData();
for (int index = 0; index < count; index++) {
dataStream.write(Native.getByte(ptr + index));
}
}
data = dataStream.toByteArray();
} finally {
incrDataGetter.dispose();
}
}
} else {
XToolkit.awtLock();
try {
XlibWrapper.XDeleteProperty(XToolkit.getDisplay(),
XWindow.getXAWTRootWindow().getWindow(),
selectionPropertyAtom.getAtom());
} finally {
XToolkit.awtUnlock();
}
if (dataGetter.getActualFormat() != 8) {
throw new IOException("Unsupported data format: " +
dataGetter.getActualFormat());
}
int count = dataGetter.getNumberOfItems();
if (count > 0) {
data = new byte[count];
long ptr = dataGetter.getData();
for (int index = 0; index < count; index++) {
data[index] = Native.getByte(ptr + index);
}
}
}
} finally {
dataGetter.dispose();
}
}
return data != null ? data : new byte[0];
}
// To be MT-safe this method should be called under awtLock.
boolean isOwner() {
return isOwner;
}
// To be MT-safe this method should be called under awtLock.
private void setOwnerProp(boolean f) {
isOwner = f;
fireOwnershipChanges(isOwner);
}
private void lostOwnership() {
setOwnerProp(false);
}
public synchronized void reset() {
contents = null;
formatMap = null;
formats = null;
appContext = null;
ownershipTime = 0;
}
// Converts the data to the 'format' and if the conversion succeeded stores
// the data in the 'property' on the 'requestor' window.
// Returns true if the conversion succeeded.
private boolean convertAndStore(long requestor, long format, long property) {
int dataFormat = 8; /* Can choose between 8,16,32. */
byte[] byteData = null;
long nativeDataPtr = 0;
int count = 0;
try {
SunToolkit.insertTargetMapping(this, appContext);
byteData = DataTransferer.getInstance().convertData(this,
contents,
format,
formatMap,
XToolkit.isToolkitThread());
} catch (IOException ioe) {
return false;
}
if (byteData == null) {
return false;
}
count = byteData.length;
try {
if (count > 0) {
if (count <= MAX_PROPERTY_SIZE) {
nativeDataPtr = Native.toData(byteData);
} else {
// Initiate incremental data transfer.
new IncrementalDataProvider(requestor, property, format, 8,
byteData);
nativeDataPtr =
XlibWrapper.unsafe.allocateMemory(XAtom.getAtomSize());
Native.putLong(nativeDataPtr, (long)count);
format = XDataTransferer.INCR_ATOM.getAtom();
dataFormat = 32;
count = 1;
}
}
XToolkit.awtLock();
try {
XlibWrapper.XChangeProperty(XToolkit.getDisplay(), requestor, property,
format, dataFormat,
XConstants.PropModeReplace,
nativeDataPtr, count);
} finally {
XToolkit.awtUnlock();
}
} finally {
if (nativeDataPtr != 0) {
XlibWrapper.unsafe.freeMemory(nativeDataPtr);
nativeDataPtr = 0;
}
}
return true;
}
private void handleSelectionRequest(XSelectionRequestEvent xsre) {
long property = xsre.get_property();
final long requestor = xsre.get_requestor();
final long requestTime = xsre.get_time();
final long format = xsre.get_target();
boolean conversionSucceeded = false;
if (ownershipTime != 0 &&
(requestTime == XConstants.CurrentTime || requestTime >= ownershipTime))
{
// Handle MULTIPLE requests as per ICCCM.
if (format == XDataTransferer.MULTIPLE_ATOM.getAtom()) {
conversionSucceeded = handleMultipleRequest(requestor, property);
} else {
// Support for obsolete clients as per ICCCM.
if (property == XConstants.None) {
property = format;
}
if (format == XDataTransferer.TARGETS_ATOM.getAtom()) {
conversionSucceeded = handleTargetsRequest(property, requestor);
} else {
conversionSucceeded = convertAndStore(requestor, format, property);
}
}
}
if (!conversionSucceeded) {
// None property indicates conversion failure.
property = XConstants.None;
}
XSelectionEvent xse = new XSelectionEvent();
try {
xse.set_type(XConstants.SelectionNotify);
xse.set_send_event(true);
xse.set_requestor(requestor);
xse.set_selection(selectionAtom.getAtom());
xse.set_target(format);
xse.set_property(property);
xse.set_time(requestTime);
XToolkit.awtLock();
try {
XlibWrapper.XSendEvent(XToolkit.getDisplay(), requestor, false,
XConstants.NoEventMask, xse.pData);
} finally {
XToolkit.awtUnlock();
}
} finally {
xse.dispose();
}
}
private boolean handleMultipleRequest(final long requestor, long property) {
if (XConstants.None == property) {
// The property cannot be None for a MULTIPLE request.
return false;
}
boolean conversionSucceeded = false;
// First retrieve the list of requested targets.
WindowPropertyGetter wpg =
new WindowPropertyGetter(requestor, XAtom.get(property),
0, MAX_LENGTH, false,
XConstants.AnyPropertyType);
try {
wpg.execute();
if (wpg.getActualFormat() == 32 && (wpg.getNumberOfItems() % 2) == 0) {
final long count = wpg.getNumberOfItems() / 2;
final long pairsPtr = wpg.getData();
boolean writeBack = false;
for (int i = 0; i < count; i++) {
long target = Native.getLong(pairsPtr, 2 * i);
long prop = Native.getLong(pairsPtr, 2 * i + 1);
if (!convertAndStore(requestor, target, prop)) {
// To report failure, we should replace the
// target atom with 0 in the MULTIPLE property.
Native.putLong(pairsPtr, 2 * i, 0);
writeBack = true;
}
}
if (writeBack) {
XToolkit.awtLock();
try {
XlibWrapper.XChangeProperty(XToolkit.getDisplay(),
requestor,
property,
wpg.getActualType(),
wpg.getActualFormat(),
XConstants.PropModeReplace,
wpg.getData(),
wpg.getNumberOfItems());
} finally {
XToolkit.awtUnlock();
}
}
conversionSucceeded = true;
}
} finally {
wpg.dispose();
}
return conversionSucceeded;
}
private boolean handleTargetsRequest(long property, long requestor)
throws IllegalStateException
{
boolean conversionSucceeded = false;
// Use a local copy to avoid synchronization.
long[] formatsLocal = formats;
if (formatsLocal == null) {
throw new IllegalStateException("Not an owner.");
}
long nativeDataPtr = 0;
try {
final int count = formatsLocal.length;
final int dataFormat = 32;
if (count > 0) {
nativeDataPtr = Native.allocateLongArray(count);
Native.put(nativeDataPtr, formatsLocal);
}
conversionSucceeded = true;
XToolkit.awtLock();
try {
XlibWrapper.XChangeProperty(XToolkit.getDisplay(), requestor,
property, XAtom.XA_ATOM, dataFormat,
XConstants.PropModeReplace,
nativeDataPtr, count);
} finally {
XToolkit.awtUnlock();
}
} finally {
if (nativeDataPtr != 0) {
XlibWrapper.unsafe.freeMemory(nativeDataPtr);
nativeDataPtr = 0;
}
}
return conversionSucceeded;
}
private void fireOwnershipChanges(final boolean isOwner) {
OwnershipListener l = null;
synchronized (stateLock) {
l = ownershipListener;
}
if (null != l) {
l.ownershipChanged(isOwner);
}
}
void registerOwershipListener(OwnershipListener l) {
synchronized (stateLock) {
ownershipListener = l;
}
}
void unregisterOwnershipListener() {
synchronized (stateLock) {
ownershipListener = null;
}
}
private static class SelectionEventHandler implements XEventDispatcher {
public void dispatchEvent(XEvent ev) {
switch (ev.get_type()) {
case XConstants.SelectionNotify: {
XToolkit.awtLock();
try {
XSelectionEvent xse = ev.get_xselection();
// Ignore the SelectionNotify event if it is not the response to our last request.
if (propertyGetter != null && xse.get_time() == lastRequestServerTime) {
// The property will be None in case of convertion failure.
if (xse.get_property() == selectionPropertyAtom.getAtom()) {
propertyGetter.execute();
propertyGetter = null;
} else if (xse.get_property() == 0) {
propertyGetter.dispose();
propertyGetter = null;
}
}
XToolkit.awtLockNotifyAll();
} finally {
XToolkit.awtUnlock();
}
break;
}
case XConstants.SelectionRequest: {
XSelectionRequestEvent xsre = ev.get_xselectionrequest();
long atom = xsre.get_selection();
XSelection selection = XSelection.getSelection(XAtom.get(atom));
if (selection != null) {
selection.handleSelectionRequest(xsre);
}
break;
}
case XConstants.SelectionClear: {
XSelectionClearEvent xsce = ev.get_xselectionclear();
long atom = xsce.get_selection();
XSelection selection = XSelection.getSelection(XAtom.get(atom));
if (selection != null) {
selection.lostOwnership();
}
XToolkit.awtLock();
try {
XToolkit.awtLockNotifyAll();
} finally {
XToolkit.awtUnlock();
}
break;
}
}
}
};
private static class IncrementalDataProvider implements XEventDispatcher {
private final long requestor;
private final long property;
private final long target;
private final int format;
private final byte[] data;
private int offset = 0;
// NOTE: formats other than 8 are not supported.
public IncrementalDataProvider(long requestor, long property,
long target, int format, byte[] data) {
if (format != 8) {
throw new IllegalArgumentException("Unsupported format: " + format);
}
this.requestor = requestor;
this.property = property;
this.target = target;
this.format = format;
this.data = data;
XWindowAttributes wattr = new XWindowAttributes();
try {
XToolkit.awtLock();
try {
XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(), requestor,
wattr.pData);
XlibWrapper.XSelectInput(XToolkit.getDisplay(), requestor,
wattr.get_your_event_mask() |
XConstants.PropertyChangeMask);
} finally {
XToolkit.awtUnlock();
}
} finally {
wattr.dispose();
}
XToolkit.addEventDispatcher(requestor, this);
}
public void dispatchEvent(XEvent ev) {
switch (ev.get_type()) {
case XConstants.PropertyNotify:
XPropertyEvent xpe = ev.get_xproperty();
if (xpe.get_window() == requestor &&
xpe.get_state() == XConstants.PropertyDelete &&
xpe.get_atom() == property) {
int count = data.length - offset;
long nativeDataPtr = 0;
if (count > MAX_PROPERTY_SIZE) {
count = MAX_PROPERTY_SIZE;
}
if (count > 0) {
nativeDataPtr = XlibWrapper.unsafe.allocateMemory(count);
for (int i = 0; i < count; i++) {
Native.putByte(nativeDataPtr+i, data[offset + i]);
}
} else {
assert (count == 0);
// All data has been transferred.
// This zero-length data indicates end of transfer.
XToolkit.removeEventDispatcher(requestor, this);
}
XToolkit.awtLock();
try {
XlibWrapper.XChangeProperty(XToolkit.getDisplay(),
requestor, property,
target, format,
XConstants.PropModeReplace,
nativeDataPtr, count);
} finally {
XToolkit.awtUnlock();
}
if (nativeDataPtr != 0) {
XlibWrapper.unsafe.freeMemory(nativeDataPtr);
nativeDataPtr = 0;
}
offset += count;
}
}
}
}
private static class IncrementalTransferHandler implements XEventDispatcher {
public void dispatchEvent(XEvent ev) {
switch (ev.get_type()) {
case XConstants.PropertyNotify:
XPropertyEvent xpe = ev.get_xproperty();
if (xpe.get_state() == XConstants.PropertyNewValue &&
xpe.get_atom() == selectionPropertyAtom.getAtom()) {
XToolkit.awtLock();
try {
if (propertyGetter != null) {
propertyGetter.execute();
propertyGetter = null;
}
XToolkit.awtLockNotifyAll();
} finally {
XToolkit.awtUnlock();
}
}
break;
}
}
};
}