private static void writeLogRecords(PrintStream logps) throws Exception {
PrintStream err = System.err;
try {
System.setErr(logps);
Object[] params = new Object[] {new Long(1), "string"};
PlatformLogger plog = PlatformLogger.getLogger("test.log.foo");
plog.severe("Log message {0} {1}", (Object[]) params);
// create a java.util.logging.Logger
// now java.util.logging.Logger should be created for each platform
// logger
Logger logger = Logger.getLogger("test.log.bar");
logger.log(Level.SEVERE, "Log message {0} {1}", params);
plog.severe("Log message {0} {1}", (Object[]) params);
} finally {
logps.flush();
logps.close();
System.setErr(err);
}
}
public class CPlatformWindow extends CFRetainedResource implements PlatformWindow {
private native long nativeCreateNSWindow(
long nsViewPtr, long ownerPtr, long styleBits, double x, double y, double w, double h);
private static native void nativeSetNSWindowStyleBits(long nsWindowPtr, int mask, int data);
private static native void nativeSetNSWindowMenuBar(long nsWindowPtr, long menuBarPtr);
private static native Insets nativeGetNSWindowInsets(long nsWindowPtr);
private static native void nativeSetNSWindowBounds(
long nsWindowPtr, double x, double y, double w, double h);
private static native void nativeSetNSWindowLocationByPlatform(long nsWindowPtr);
private static native void nativeSetNSWindowStandardFrame(
long nsWindowPtr, double x, double y, double w, double h);
private static native void nativeSetNSWindowMinMax(
long nsWindowPtr, double minW, double minH, double maxW, double maxH);
private static native void nativePushNSWindowToBack(long nsWindowPtr);
private static native void nativePushNSWindowToFront(long nsWindowPtr);
private static native void nativeSetNSWindowTitle(long nsWindowPtr, String title);
private static native void nativeRevalidateNSWindowShadow(long nsWindowPtr);
private static native void nativeSetNSWindowMinimizedIcon(long nsWindowPtr, long nsImage);
private static native void nativeSetNSWindowRepresentedFilename(
long nsWindowPtr, String representedFilename);
private static native void nativeSetEnabled(long nsWindowPtr, boolean isEnabled);
private static native void nativeSynthesizeMouseEnteredExitedEvents();
private static native void nativeSynthesizeMouseEnteredExitedEvents(
long nsWindowPtr, int eventType);
private static native void nativeDispose(long nsWindowPtr);
private static native void nativeEnterFullScreenMode(long nsWindowPtr);
private static native void nativeExitFullScreenMode(long nsWindowPtr);
static native CPlatformWindow nativeGetTopmostPlatformWindowUnderMouse();
// Loger to report issues happened during execution but that do not affect functionality
private static final PlatformLogger logger =
PlatformLogger.getLogger("sun.lwawt.macosx.CPlatformWindow");
private static final PlatformLogger focusLogger =
PlatformLogger.getLogger("sun.lwawt.macosx.focus.CPlatformWindow");
// for client properties
public static final String WINDOW_BRUSH_METAL_LOOK = "apple.awt.brushMetalLook";
public static final String WINDOW_DRAGGABLE_BACKGROUND = "apple.awt.draggableWindowBackground";
public static final String WINDOW_ALPHA = "Window.alpha";
public static final String WINDOW_SHADOW = "Window.shadow";
public static final String WINDOW_STYLE = "Window.style";
public static final String WINDOW_SHADOW_REVALIDATE_NOW = "apple.awt.windowShadow.revalidateNow";
public static final String WINDOW_DOCUMENT_MODIFIED = "Window.documentModified";
public static final String WINDOW_DOCUMENT_FILE = "Window.documentFile";
public static final String WINDOW_CLOSEABLE = "Window.closeable";
public static final String WINDOW_MINIMIZABLE = "Window.minimizable";
public static final String WINDOW_ZOOMABLE = "Window.zoomable";
public static final String WINDOW_HIDES_ON_DEACTIVATE = "Window.hidesOnDeactivate";
public static final String WINDOW_DOC_MODAL_SHEET = "apple.awt.documentModalSheet";
public static final String WINDOW_FADE_DELEGATE = "apple.awt._windowFadeDelegate";
public static final String WINDOW_FADE_IN = "apple.awt._windowFadeIn";
public static final String WINDOW_FADE_OUT = "apple.awt._windowFadeOut";
public static final String WINDOW_FULLSCREENABLE = "apple.awt.fullscreenable";
// Yeah, I know. But it's easier to deal with ints from JNI
static final int MODELESS = 0;
static final int DOCUMENT_MODAL = 1;
static final int APPLICATION_MODAL = 2;
static final int TOOLKIT_MODAL = 3;
// window style bits
static final int _RESERVED_FOR_DATA = 1 << 0;
// corresponds to native style mask bits
static final int DECORATED = 1 << 1;
static final int TEXTURED = 1 << 2;
static final int UNIFIED = 1 << 3;
static final int UTILITY = 1 << 4;
static final int HUD = 1 << 5;
static final int SHEET = 1 << 6;
static final int CLOSEABLE = 1 << 7;
static final int MINIMIZABLE = 1 << 8;
static final int RESIZABLE = 1 << 9; // both a style bit and prop bit
static final int NONACTIVATING = 1 << 24;
static final int IS_DIALOG = 1 << 25;
static final int IS_MODAL = 1 << 26;
static final int IS_POPUP = 1 << 27;
static final int _STYLE_PROP_BITMASK =
DECORATED | TEXTURED | UNIFIED | UTILITY | HUD | SHEET | CLOSEABLE | MINIMIZABLE | RESIZABLE;
// corresponds to method-based properties
static final int HAS_SHADOW = 1 << 10;
static final int ZOOMABLE = 1 << 11;
static final int ALWAYS_ON_TOP = 1 << 15;
static final int HIDES_ON_DEACTIVATE = 1 << 17;
static final int DRAGGABLE_BACKGROUND = 1 << 19;
static final int DOCUMENT_MODIFIED = 1 << 21;
static final int FULLSCREENABLE = 1 << 23;
static final int _METHOD_PROP_BITMASK =
RESIZABLE
| HAS_SHADOW
| ZOOMABLE
| ALWAYS_ON_TOP
| HIDES_ON_DEACTIVATE
| DRAGGABLE_BACKGROUND
| DOCUMENT_MODIFIED
| FULLSCREENABLE;
// corresponds to callback-based properties
static final int SHOULD_BECOME_KEY = 1 << 12;
static final int SHOULD_BECOME_MAIN = 1 << 13;
static final int MODAL_EXCLUDED = 1 << 16;
static final int _CALLBACK_PROP_BITMASK = SHOULD_BECOME_KEY | SHOULD_BECOME_MAIN | MODAL_EXCLUDED;
static int SET(final int bits, final int mask, final boolean value) {
if (value) return (bits | mask);
return bits & ~mask;
}
static boolean IS(final int bits, final int mask) {
return (bits & mask) != 0;
}
@SuppressWarnings({"unchecked", "rawtypes"})
static ClientPropertyApplicator<JRootPane, CPlatformWindow> CLIENT_PROPERTY_APPLICATOR =
new ClientPropertyApplicator<JRootPane, CPlatformWindow>(
new Property[] {
new Property<CPlatformWindow>(WINDOW_DOCUMENT_MODIFIED) {
public void applyProperty(final CPlatformWindow c, final Object value) {
c.setStyleBits(
DOCUMENT_MODIFIED,
value == null ? false : Boolean.parseBoolean(value.toString()));
}
},
new Property<CPlatformWindow>(WINDOW_BRUSH_METAL_LOOK) {
public void applyProperty(final CPlatformWindow c, final Object value) {
c.setStyleBits(TEXTURED, Boolean.parseBoolean(value.toString()));
}
},
new Property<CPlatformWindow>(WINDOW_ALPHA) {
public void applyProperty(final CPlatformWindow c, final Object value) {
AWTUtilities.setWindowOpacity(
c.target, value == null ? 1.0f : Float.parseFloat(value.toString()));
}
},
new Property<CPlatformWindow>(WINDOW_SHADOW) {
public void applyProperty(final CPlatformWindow c, final Object value) {
c.setStyleBits(
HAS_SHADOW, value == null ? true : Boolean.parseBoolean(value.toString()));
}
},
new Property<CPlatformWindow>(WINDOW_MINIMIZABLE) {
public void applyProperty(final CPlatformWindow c, final Object value) {
c.setStyleBits(MINIMIZABLE, Boolean.parseBoolean(value.toString()));
}
},
new Property<CPlatformWindow>(WINDOW_CLOSEABLE) {
public void applyProperty(final CPlatformWindow c, final Object value) {
c.setStyleBits(CLOSEABLE, Boolean.parseBoolean(value.toString()));
}
},
new Property<CPlatformWindow>(WINDOW_ZOOMABLE) {
public void applyProperty(final CPlatformWindow c, final Object value) {
boolean zoomable = Boolean.parseBoolean(value.toString());
if (c.target instanceof RootPaneContainer
&& c.getPeer().getPeerType() == PeerType.FRAME) {
if (c.isInFullScreen && !zoomable) {
c.toggleFullScreen();
}
}
c.setStyleBits(ZOOMABLE, zoomable);
}
},
new Property<CPlatformWindow>(WINDOW_FULLSCREENABLE) {
public void applyProperty(final CPlatformWindow c, final Object value) {
boolean fullscrenable = Boolean.parseBoolean(value.toString());
if (c.target instanceof RootPaneContainer
&& c.getPeer().getPeerType() == PeerType.FRAME) {
if (c.isInFullScreen && !fullscrenable) {
c.toggleFullScreen();
}
}
c.setStyleBits(FULLSCREENABLE, fullscrenable);
}
},
new Property<CPlatformWindow>(WINDOW_SHADOW_REVALIDATE_NOW) {
public void applyProperty(final CPlatformWindow c, final Object value) {
nativeRevalidateNSWindowShadow(c.getNSWindowPtr());
}
},
new Property<CPlatformWindow>(WINDOW_DOCUMENT_FILE) {
public void applyProperty(final CPlatformWindow c, final Object value) {
if (value == null || !(value instanceof java.io.File)) {
nativeSetNSWindowRepresentedFilename(c.getNSWindowPtr(), null);
return;
}
final String filename = ((java.io.File) value).getAbsolutePath();
nativeSetNSWindowRepresentedFilename(c.getNSWindowPtr(), filename);
}
}
}) {
@SuppressWarnings("deprecation")
public CPlatformWindow convertJComponentToTarget(final JRootPane p) {
Component root = SwingUtilities.getRoot(p);
final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
if (root == null || acc.getPeer(root) == null) return null;
return (CPlatformWindow) ((LWWindowPeer) acc.getPeer(root)).getPlatformWindow();
}
};
// Bounds of the native widget but in the Java coordinate system.
// In order to keep it up-to-date we will update them on
// 1) setting native bounds via nativeSetBounds() call
// 2) getting notification from the native level via deliverMoveResizeEvent()
private Rectangle nativeBounds = new Rectangle(0, 0, 0, 0);
private volatile boolean isFullScreenMode;
private boolean isFullScreenAnimationOn;
private volatile boolean isInFullScreen;
private Window target;
private LWWindowPeer peer;
protected CPlatformView contentView;
protected CPlatformWindow owner;
protected boolean visible = false; // visibility status from native perspective
private boolean undecorated; // initialized in getInitialStyleBits()
private Rectangle normalBounds = null; // not-null only for undecorated maximized windows
private CPlatformResponder responder;
public CPlatformWindow() {
super(0, true);
}
/*
* Delegate initialization (create native window and all the
* related resources).
*/
@Override // PlatformWindow
public void initialize(Window _target, LWWindowPeer _peer, PlatformWindow _owner) {
initializeBase(_target, _peer, _owner, new CPlatformView());
final int styleBits = getInitialStyleBits();
responder = createPlatformResponder();
contentView = createContentView();
contentView.initialize(peer, responder);
final long ownerPtr = owner != null ? owner.getNSWindowPtr() : 0L;
Rectangle bounds;
if (!IS(DECORATED, styleBits)) {
// For undecorated frames the move/resize event does not come if the frame is centered on the
// screen
// so we need to set a stub location to force an initial move/resize. Real bounds would be set
// later.
bounds = new Rectangle(0, 0, 1, 1);
} else {
bounds = _peer.constrainBounds(_target.getBounds());
}
final long nativeWindowPtr =
nativeCreateNSWindow(
contentView.getAWTView(),
ownerPtr,
styleBits,
bounds.x,
bounds.y,
bounds.width,
bounds.height);
setPtr(nativeWindowPtr);
if (target instanceof javax.swing.RootPaneContainer) {
final javax.swing.JRootPane rootpane = ((javax.swing.RootPaneContainer) target).getRootPane();
if (rootpane != null)
rootpane.addPropertyChangeListener(
"ancestor",
new PropertyChangeListener() {
public void propertyChange(final PropertyChangeEvent evt) {
CLIENT_PROPERTY_APPLICATOR.attachAndApplyClientProperties(rootpane);
rootpane.removePropertyChangeListener("ancestor", this);
}
});
}
validateSurface();
}
protected void initializeBase(
Window target, LWWindowPeer peer, PlatformWindow owner, CPlatformView view) {
this.peer = peer;
this.target = target;
if (owner instanceof CPlatformWindow) {
this.owner = (CPlatformWindow) owner;
}
this.contentView = view;
}
protected CPlatformResponder createPlatformResponder() {
return new CPlatformResponder(peer, false);
}
protected CPlatformView createContentView() {
return new CPlatformView();
}
protected int getInitialStyleBits() {
// defaults style bits
int styleBits = DECORATED | HAS_SHADOW | CLOSEABLE | MINIMIZABLE | ZOOMABLE | RESIZABLE;
if (isNativelyFocusableWindow()) {
styleBits = SET(styleBits, SHOULD_BECOME_KEY, true);
styleBits = SET(styleBits, SHOULD_BECOME_MAIN, true);
}
final boolean isFrame = (target instanceof Frame);
final boolean isDialog = (target instanceof Dialog);
final boolean isPopup = (target.getType() == Window.Type.POPUP);
if (isDialog) {
styleBits = SET(styleBits, MINIMIZABLE, false);
}
// Either java.awt.Frame or java.awt.Dialog can be undecorated, however java.awt.Window always
// is undecorated.
{
this.undecorated =
isFrame
? ((Frame) target).isUndecorated()
: (isDialog ? ((Dialog) target).isUndecorated() : true);
if (this.undecorated) styleBits = SET(styleBits, DECORATED, false);
}
// Either java.awt.Frame or java.awt.Dialog can be resizable, however java.awt.Window is never
// resizable
{
final boolean resizable =
isFrame
? ((Frame) target).isResizable()
: (isDialog ? ((Dialog) target).isResizable() : false);
styleBits = SET(styleBits, RESIZABLE, resizable);
if (!resizable) {
styleBits = SET(styleBits, ZOOMABLE, false);
} else {
setCanFullscreen(true);
}
}
if (target.isAlwaysOnTop()) {
styleBits = SET(styleBits, ALWAYS_ON_TOP, true);
}
if (target.getModalExclusionType() == Dialog.ModalExclusionType.APPLICATION_EXCLUDE) {
styleBits = SET(styleBits, MODAL_EXCLUDED, true);
}
// If the target is a dialog, popup or tooltip we want it to ignore the brushed metal look.
if (isPopup) {
styleBits = SET(styleBits, TEXTURED, false);
// Popups in applets don't activate applet's process
styleBits = SET(styleBits, NONACTIVATING, true);
styleBits = SET(styleBits, IS_POPUP, true);
}
if (Window.Type.UTILITY.equals(target.getType())) {
styleBits = SET(styleBits, UTILITY, true);
}
if (target instanceof javax.swing.RootPaneContainer) {
javax.swing.JRootPane rootpane = ((javax.swing.RootPaneContainer) target).getRootPane();
Object prop = null;
prop = rootpane.getClientProperty(WINDOW_BRUSH_METAL_LOOK);
if (prop != null) {
styleBits = SET(styleBits, TEXTURED, Boolean.parseBoolean(prop.toString()));
}
if (isDialog && ((Dialog) target).getModalityType() == ModalityType.DOCUMENT_MODAL) {
prop = rootpane.getClientProperty(WINDOW_DOC_MODAL_SHEET);
if (prop != null) {
styleBits = SET(styleBits, SHEET, Boolean.parseBoolean(prop.toString()));
}
}
prop = rootpane.getClientProperty(WINDOW_STYLE);
if (prop != null) {
if ("small".equals(prop)) {
styleBits = SET(styleBits, UTILITY, true);
if (target.isAlwaysOnTop()
&& rootpane.getClientProperty(WINDOW_HIDES_ON_DEACTIVATE) == null) {
styleBits = SET(styleBits, HIDES_ON_DEACTIVATE, true);
}
}
if ("textured".equals(prop)) styleBits = SET(styleBits, TEXTURED, true);
if ("unified".equals(prop)) styleBits = SET(styleBits, UNIFIED, true);
if ("hud".equals(prop)) styleBits = SET(styleBits, HUD, true);
}
prop = rootpane.getClientProperty(WINDOW_HIDES_ON_DEACTIVATE);
if (prop != null) {
styleBits = SET(styleBits, HIDES_ON_DEACTIVATE, Boolean.parseBoolean(prop.toString()));
}
prop = rootpane.getClientProperty(WINDOW_CLOSEABLE);
if (prop != null) {
styleBits = SET(styleBits, CLOSEABLE, Boolean.parseBoolean(prop.toString()));
}
prop = rootpane.getClientProperty(WINDOW_MINIMIZABLE);
if (prop != null) {
styleBits = SET(styleBits, MINIMIZABLE, Boolean.parseBoolean(prop.toString()));
}
prop = rootpane.getClientProperty(WINDOW_ZOOMABLE);
if (prop != null) {
styleBits = SET(styleBits, ZOOMABLE, Boolean.parseBoolean(prop.toString()));
}
prop = rootpane.getClientProperty(WINDOW_FULLSCREENABLE);
if (prop != null) {
styleBits = SET(styleBits, FULLSCREENABLE, Boolean.parseBoolean(prop.toString()));
}
prop = rootpane.getClientProperty(WINDOW_SHADOW);
if (prop != null) {
styleBits = SET(styleBits, HAS_SHADOW, Boolean.parseBoolean(prop.toString()));
}
prop = rootpane.getClientProperty(WINDOW_DRAGGABLE_BACKGROUND);
if (prop != null) {
styleBits = SET(styleBits, DRAGGABLE_BACKGROUND, Boolean.parseBoolean(prop.toString()));
}
}
if (isDialog) {
styleBits = SET(styleBits, IS_DIALOG, true);
if (((Dialog) target).isModal()) {
styleBits = SET(styleBits, IS_MODAL, true);
}
}
peer.setTextured(IS(TEXTURED, styleBits));
return styleBits;
}
// this is the counter-point to -[CWindow _nativeSetStyleBit:]
private void setStyleBits(final int mask, final boolean value) {
nativeSetNSWindowStyleBits(getNSWindowPtr(), mask, value ? mask : 0);
}
private native void _toggleFullScreenMode(final long model);
public void toggleFullScreen() {
_toggleFullScreenMode(getNSWindowPtr());
}
@Override // PlatformWindow
public void setMenuBar(MenuBar mb) {
final long nsWindowPtr = getNSWindowPtr();
CMenuBar mbPeer = (CMenuBar) LWToolkit.targetToPeer(mb);
if (mbPeer != null) {
nativeSetNSWindowMenuBar(nsWindowPtr, mbPeer.getModel());
} else {
nativeSetNSWindowMenuBar(nsWindowPtr, 0);
}
}
@Override // PlatformWindow
public void dispose() {
contentView.dispose();
nativeDispose(getNSWindowPtr());
CPlatformWindow.super.dispose();
}
@Override // PlatformWindow
public FontMetrics getFontMetrics(Font f) {
// TODO: not implemented
(new RuntimeException("unimplemented")).printStackTrace();
return null;
}
@Override // PlatformWindow
public Insets getInsets() {
return nativeGetNSWindowInsets(getNSWindowPtr());
}
@Override // PlatformWindow
public Point getLocationOnScreen() {
return new Point(nativeBounds.x, nativeBounds.y);
}
@Override
public GraphicsDevice getGraphicsDevice() {
return contentView.getGraphicsDevice();
}
@Override // PlatformWindow
public SurfaceData getScreenSurface() {
// TODO: not implemented
return null;
}
@Override // PlatformWindow
public SurfaceData replaceSurfaceData() {
return contentView.replaceSurfaceData();
}
@Override // PlatformWindow
public void setBounds(int x, int y, int w, int h) {
nativeSetNSWindowBounds(getNSWindowPtr(), x, y, w, h);
}
public void setMaximizedBounds(int x, int y, int w, int h) {
nativeSetNSWindowStandardFrame(getNSWindowPtr(), x, y, w, h);
}
private boolean isMaximized() {
return undecorated ? this.normalBounds != null : CWrapper.NSWindow.isZoomed(getNSWindowPtr());
}
private void maximize() {
if (peer == null || isMaximized()) {
return;
}
if (!undecorated) {
CWrapper.NSWindow.zoom(getNSWindowPtr());
} else {
deliverZoom(true);
// We need an up to date size of the peer, so we flush the native events
// to be sure that there are no setBounds requests in the queue.
LWCToolkit.flushNativeSelectors();
this.normalBounds = peer.getBounds();
Rectangle maximizedBounds = peer.getMaximizedBounds();
setBounds(
maximizedBounds.x, maximizedBounds.y, maximizedBounds.width, maximizedBounds.height);
}
}
private void unmaximize() {
if (!isMaximized()) {
return;
}
if (!undecorated) {
CWrapper.NSWindow.zoom(getNSWindowPtr());
} else {
deliverZoom(false);
Rectangle toBounds = this.normalBounds;
this.normalBounds = null;
setBounds(toBounds.x, toBounds.y, toBounds.width, toBounds.height);
}
}
public boolean isVisible() {
return this.visible;
}
@Override // PlatformWindow
public void setVisible(boolean visible) {
final long nsWindowPtr = getNSWindowPtr();
// Configure stuff
updateIconImages();
updateFocusabilityForAutoRequestFocus(false);
boolean wasMaximized = isMaximized();
if (visible && target.isLocationByPlatform()) {
nativeSetNSWindowLocationByPlatform(getNSWindowPtr());
}
// Actually show or hide the window
LWWindowPeer blocker = (peer == null) ? null : peer.getBlocker();
if (blocker == null || !visible) {
// If it ain't blocked, or is being hidden, go regular way
if (visible) {
CWrapper.NSWindow.makeFirstResponder(nsWindowPtr, contentView.getAWTView());
boolean isPopup = (target.getType() == Window.Type.POPUP);
if (isPopup) {
// Popups in applets don't activate applet's process
CWrapper.NSWindow.orderFrontRegardless(nsWindowPtr);
} else {
CWrapper.NSWindow.orderFront(nsWindowPtr);
}
boolean isKeyWindow = CWrapper.NSWindow.isKeyWindow(nsWindowPtr);
if (!isKeyWindow) {
CWrapper.NSWindow.makeKeyWindow(nsWindowPtr);
}
} else {
// immediately hide the window
CWrapper.NSWindow.orderOut(nsWindowPtr);
// process the close
CWrapper.NSWindow.close(nsWindowPtr);
}
} else {
// otherwise, put it in a proper z-order
CWrapper.NSWindow.orderWindow(
nsWindowPtr,
CWrapper.NSWindow.NSWindowBelow,
((CPlatformWindow) blocker.getPlatformWindow()).getNSWindowPtr());
}
this.visible = visible;
// Manage the extended state when showing
if (visible) {
// Apply the extended state as expected in shared code
if (target instanceof Frame) {
if (!wasMaximized && isMaximized()) {
// setVisible could have changed the native maximized state
deliverZoom(true);
} else {
int frameState = ((Frame) target).getExtendedState();
if ((frameState & Frame.ICONIFIED) != 0) {
// Treat all state bit masks with ICONIFIED bit as ICONIFIED state.
frameState = Frame.ICONIFIED;
}
switch (frameState) {
case Frame.ICONIFIED:
CWrapper.NSWindow.miniaturize(nsWindowPtr);
break;
case Frame.MAXIMIZED_BOTH:
maximize();
break;
default: // NORMAL
unmaximize(); // in case it was maximized, otherwise this is a no-op
break;
}
}
}
}
nativeSynthesizeMouseEnteredExitedEvents();
// Configure stuff #2
updateFocusabilityForAutoRequestFocus(true);
// Manage parent-child relationship when showing
final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
if (visible) {
// Order myself above my parent
if (owner != null && owner.isVisible()) {
CWrapper.NSWindow.orderWindow(
nsWindowPtr, CWrapper.NSWindow.NSWindowAbove, owner.getNSWindowPtr());
applyWindowLevel(target);
}
// Order my own children above myself
for (Window w : target.getOwnedWindows()) {
final Object p = acc.getPeer(w);
if (p instanceof LWWindowPeer) {
CPlatformWindow pw = (CPlatformWindow) ((LWWindowPeer) p).getPlatformWindow();
if (pw != null && pw.isVisible()) {
CWrapper.NSWindow.orderWindow(
pw.getNSWindowPtr(), CWrapper.NSWindow.NSWindowAbove, nsWindowPtr);
pw.applyWindowLevel(w);
}
}
}
}
// Deal with the blocker of the window being shown
if (blocker != null && visible) {
// Make sure the blocker is above its siblings
((CPlatformWindow) blocker.getPlatformWindow()).orderAboveSiblings();
}
}
@Override // PlatformWindow
public void setTitle(String title) {
nativeSetNSWindowTitle(getNSWindowPtr(), title);
}
// Should be called on every window key property change.
@Override // PlatformWindow
public void updateIconImages() {
final long nsWindowPtr = getNSWindowPtr();
final CImage cImage = getImageForTarget();
nativeSetNSWindowMinimizedIcon(nsWindowPtr, cImage == null ? 0L : cImage.ptr);
}
public long getNSWindowPtr() {
final long nsWindowPtr = ptr;
if (nsWindowPtr == 0L) {
if (logger.isLoggable(PlatformLogger.Level.FINE)) {
logger.fine(
"NSWindow already disposed?", new Exception("Pointer to native NSWindow is invalid."));
}
}
return nsWindowPtr;
}
public SurfaceData getSurfaceData() {
return contentView.getSurfaceData();
}
@Override // PlatformWindow
public void toBack() {
final long nsWindowPtr = getNSWindowPtr();
nativePushNSWindowToBack(nsWindowPtr);
}
@Override // PlatformWindow
public void toFront() {
final long nsWindowPtr = getNSWindowPtr();
LWCToolkit lwcToolkit = (LWCToolkit) Toolkit.getDefaultToolkit();
Window w = DefaultKeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
final ComponentAccessor acc = AWTAccessor.getComponentAccessor();
if (w != null
&& acc.getPeer(w) != null
&& ((LWWindowPeer) acc.getPeer(w)).getPeerType() == LWWindowPeer.PeerType.EMBEDDED_FRAME
&& !lwcToolkit.isApplicationActive()) {
lwcToolkit.activateApplicationIgnoringOtherApps();
}
updateFocusabilityForAutoRequestFocus(false);
nativePushNSWindowToFront(nsWindowPtr);
updateFocusabilityForAutoRequestFocus(true);
}
private void setCanFullscreen(final boolean canFullScreen) {
if (target instanceof RootPaneContainer && getPeer().getPeerType() == PeerType.FRAME) {
if (isInFullScreen && !canFullScreen) {
toggleFullScreen();
}
final RootPaneContainer rpc = (RootPaneContainer) target;
rpc.getRootPane().putClientProperty(CPlatformWindow.WINDOW_FULLSCREENABLE, canFullScreen);
}
}
@Override
public void setResizable(final boolean resizable) {
setCanFullscreen(resizable);
setStyleBits(RESIZABLE, resizable);
setStyleBits(ZOOMABLE, resizable);
}
@Override
public void setSizeConstraints(int minW, int minH, int maxW, int maxH) {
nativeSetNSWindowMinMax(getNSWindowPtr(), minW, minH, maxW, maxH);
}
@Override
public boolean rejectFocusRequest(FocusEvent.Cause cause) {
// Cross-app activation requests are not allowed.
if (cause != FocusEvent.Cause.MOUSE_EVENT
&& !((LWCToolkit) Toolkit.getDefaultToolkit()).isApplicationActive()) {
focusLogger.fine("the app is inactive, so the request is rejected");
return true;
}
return false;
}
@Override
public boolean requestWindowFocus() {
long ptr = getNSWindowPtr();
if (CWrapper.NSWindow.canBecomeMainWindow(ptr)) {
CWrapper.NSWindow.makeMainWindow(ptr);
}
CWrapper.NSWindow.makeKeyAndOrderFront(ptr);
return true;
}
@Override
public boolean isActive() {
long ptr = getNSWindowPtr();
return CWrapper.NSWindow.isKeyWindow(ptr);
}
@Override
public void updateFocusableWindowState() {
final boolean isFocusable = isNativelyFocusableWindow();
setStyleBits(SHOULD_BECOME_KEY | SHOULD_BECOME_MAIN, isFocusable); // set both bits at once
}
@Override
public void setAlwaysOnTop(boolean isAlwaysOnTop) {
setStyleBits(ALWAYS_ON_TOP, isAlwaysOnTop);
}
@Override
public void setOpacity(float opacity) {
CWrapper.NSWindow.setAlphaValue(getNSWindowPtr(), opacity);
}
@Override
public void setOpaque(boolean isOpaque) {
CWrapper.NSWindow.setOpaque(getNSWindowPtr(), isOpaque);
boolean isTextured = (peer == null) ? false : peer.isTextured();
if (!isTextured) {
if (!isOpaque) {
CWrapper.NSWindow.setBackgroundColor(getNSWindowPtr(), 0);
} else if (peer != null) {
Color color = peer.getBackground();
if (color != null) {
int rgb = color.getRGB();
CWrapper.NSWindow.setBackgroundColor(getNSWindowPtr(), rgb);
}
}
}
// This is a temporary workaround. Looks like after 7124236 will be fixed
// the correct place for invalidateShadow() is CGLayer.drawInCGLContext.
SwingUtilities.invokeLater(this::invalidateShadow);
}
@Override
public void enterFullScreenMode() {
isFullScreenMode = true;
nativeEnterFullScreenMode(getNSWindowPtr());
}
@Override
public void exitFullScreenMode() {
nativeExitFullScreenMode(getNSWindowPtr());
isFullScreenMode = false;
}
@Override
public boolean isFullScreenMode() {
return isFullScreenMode;
}
@Override
public void setWindowState(int windowState) {
if (peer == null || !peer.isVisible()) {
// setVisible() applies the state
return;
}
int prevWindowState = peer.getState();
if (prevWindowState == windowState) return;
final long nsWindowPtr = getNSWindowPtr();
if ((windowState & Frame.ICONIFIED) != 0) {
// Treat all state bit masks with ICONIFIED bit as ICONIFIED state.
windowState = Frame.ICONIFIED;
}
switch (windowState) {
case Frame.ICONIFIED:
if (prevWindowState == Frame.MAXIMIZED_BOTH) {
// let's return into the normal states first
// the zoom call toggles between the normal and the max states
unmaximize();
}
CWrapper.NSWindow.miniaturize(nsWindowPtr);
break;
case Frame.MAXIMIZED_BOTH:
if (prevWindowState == Frame.ICONIFIED) {
// let's return into the normal states first
CWrapper.NSWindow.deminiaturize(nsWindowPtr);
}
maximize();
break;
case Frame.NORMAL:
if (prevWindowState == Frame.ICONIFIED) {
CWrapper.NSWindow.deminiaturize(nsWindowPtr);
} else if (prevWindowState == Frame.MAXIMIZED_BOTH) {
// the zoom call toggles between the normal and the max states
unmaximize();
}
break;
default:
throw new RuntimeException("Unknown window state: " + windowState);
}
// NOTE: the SWP.windowState field gets updated to the newWindowState
// value when the native notification comes to us
}
@Override
public void setModalBlocked(boolean blocked) {
if (target.getModalExclusionType() == Dialog.ModalExclusionType.APPLICATION_EXCLUDE) {
return;
}
if (blocked) {
// We are going to show a modal window. Previously displayed window will be
// blocked/disabled. So we have to send mouse exited event to it now, since
// all mouse events are discarded for blocked/disabled windows.
nativeSynthesizeMouseEnteredExitedEvents(getNSWindowPtr(), CocoaConstants.NSMouseExited);
}
nativeSetEnabled(getNSWindowPtr(), !blocked);
checkBlockingAndOrder();
}
public final void invalidateShadow() {
nativeRevalidateNSWindowShadow(getNSWindowPtr());
}
// ----------------------------------------------------------------------
// UTILITY METHODS
// ----------------------------------------------------------------------
/**
* Find image to install into Title or into Application icon. First try icons installed for
* toplevel. Null is returned, if there is no icon and default Duke image should be used.
*/
private CImage getImageForTarget() {
CImage icon = null;
try {
icon = CImage.getCreator().createFromImages(target.getIconImages());
} catch (Exception ignored) {
// Perhaps the icon passed into Java is broken. Skipping this icon.
}
return icon;
}
/*
* Returns LWWindowPeer associated with this delegate.
*/
@Override
public LWWindowPeer getPeer() {
return peer;
}
@Override
public boolean isUnderMouse() {
return contentView.isUnderMouse();
}
public CPlatformView getContentView() {
return contentView;
}
@Override
public long getLayerPtr() {
return contentView.getWindowLayerPtr();
}
private void validateSurface() {
SurfaceData surfaceData = getSurfaceData();
if (surfaceData instanceof CGLSurfaceData) {
((CGLSurfaceData) surfaceData).validate();
}
}
void flushBuffers() {
if (isVisible() && !nativeBounds.isEmpty() && !isFullScreenMode) {
try {
LWCToolkit.invokeAndWait(
new Runnable() {
@Override
public void run() {
// Posting an empty to flush the EventQueue without blocking the main thread
}
},
target);
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
/** Helper method to get a pointer to the native view from the PlatformWindow. */
static long getNativeViewPtr(PlatformWindow platformWindow) {
long nativePeer = 0L;
if (platformWindow instanceof CPlatformWindow) {
nativePeer = ((CPlatformWindow) platformWindow).getContentView().getAWTView();
} else if (platformWindow instanceof CViewPlatformEmbeddedFrame) {
nativePeer = ((CViewPlatformEmbeddedFrame) platformWindow).getNSViewPtr();
}
return nativePeer;
}
/**
* *********************************************************** Callbacks from the AWTWindow and
* AWTView objc classes. ***********************************************************
*/
private void deliverWindowFocusEvent(boolean gained, CPlatformWindow opposite) {
// Fix for 7150349: ingore "gained" notifications when the app is inactive.
if (gained && !((LWCToolkit) Toolkit.getDefaultToolkit()).isApplicationActive()) {
focusLogger.fine("the app is inactive, so the notification is ignored");
return;
}
LWWindowPeer oppositePeer = (opposite == null) ? null : opposite.getPeer();
responder.handleWindowFocusEvent(gained, oppositePeer);
}
protected void deliverMoveResizeEvent(int x, int y, int width, int height, boolean byUser) {
checkZoom();
final Rectangle oldB = nativeBounds;
nativeBounds = new Rectangle(x, y, width, height);
if (peer != null) {
peer.notifyReshape(x, y, width, height);
// System-dependent appearance optimization.
if ((byUser && !oldB.getSize().equals(nativeBounds.getSize())) || isFullScreenAnimationOn) {
flushBuffers();
}
}
}
private void deliverWindowClosingEvent() {
if (peer != null && peer.getBlocker() == null) {
peer.postEvent(new WindowEvent(target, WindowEvent.WINDOW_CLOSING));
}
}
private void deliverIconify(final boolean iconify) {
if (peer != null) {
peer.notifyIconify(iconify);
}
}
private void deliverZoom(final boolean isZoomed) {
if (peer != null) {
peer.notifyZoom(isZoomed);
}
}
private void checkZoom() {
if (peer != null) {
int state = peer.getState();
if (state != Frame.MAXIMIZED_BOTH && isMaximized()) {
deliverZoom(true);
} else if (state == Frame.MAXIMIZED_BOTH && !isMaximized()) {
deliverZoom(false);
}
}
}
private void deliverNCMouseDown() {
if (peer != null) {
peer.notifyNCMouseDown();
}
}
/*
* Our focus model is synthetic and only non-simple window
* may become natively focusable window.
*/
private boolean isNativelyFocusableWindow() {
if (peer == null) {
return false;
}
return !peer.isSimpleWindow() && target.getFocusableWindowState();
}
/*
* An utility method for the support of the auto request focus.
* Updates the focusable state of the window under certain
* circumstances.
*/
private void updateFocusabilityForAutoRequestFocus(boolean isFocusable) {
if (target.isAutoRequestFocus() || !isNativelyFocusableWindow()) return;
setStyleBits(SHOULD_BECOME_KEY | SHOULD_BECOME_MAIN, isFocusable); // set both bits at once
}
private boolean checkBlockingAndOrder() {
LWWindowPeer blocker = (peer == null) ? null : peer.getBlocker();
if (blocker == null) {
return false;
}
if (blocker instanceof CPrinterDialogPeer) {
return true;
}
CPlatformWindow pWindow = (CPlatformWindow) blocker.getPlatformWindow();
pWindow.orderAboveSiblings();
final long nsWindowPtr = pWindow.getNSWindowPtr();
CWrapper.NSWindow.orderFrontRegardless(nsWindowPtr);
CWrapper.NSWindow.makeKeyAndOrderFront(nsWindowPtr);
CWrapper.NSWindow.makeMainWindow(nsWindowPtr);
return true;
}
private void orderAboveSiblings() {
if (owner == null) {
return;
}
// NOTE: the logic will fail if we have a hierarchy like:
// visible root owner
// invisible owner
// visible dialog
// However, this is an unlikely scenario for real life apps
if (owner.isVisible()) {
// Recursively pop up the windows from the very bottom so that only
// the very top-most one becomes the main window
owner.orderAboveSiblings();
// Order the window to front of the stack of child windows
final long nsWindowSelfPtr = getNSWindowPtr();
final long nsWindowOwnerPtr = owner.getNSWindowPtr();
CWrapper.NSWindow.orderFront(nsWindowOwnerPtr);
CWrapper.NSWindow.orderWindow(
nsWindowSelfPtr, CWrapper.NSWindow.NSWindowAbove, nsWindowOwnerPtr);
}
applyWindowLevel(target);
}
protected void applyWindowLevel(Window target) {
if (target.isAlwaysOnTop() && target.getType() != Window.Type.POPUP) {
CWrapper.NSWindow.setLevel(getNSWindowPtr(), CWrapper.NSWindow.NSFloatingWindowLevel);
} else if (target.getType() == Window.Type.POPUP) {
CWrapper.NSWindow.setLevel(getNSWindowPtr(), CWrapper.NSWindow.NSPopUpMenuWindowLevel);
}
}
// ----------------------------------------------------------------------
// NATIVE CALLBACKS
// ----------------------------------------------------------------------
private void windowDidBecomeMain() {
if (checkBlockingAndOrder()) return;
// If it's not blocked, make sure it's above its siblings
orderAboveSiblings();
}
private void windowWillEnterFullScreen() {
isFullScreenAnimationOn = true;
}
private void windowDidEnterFullScreen() {
isInFullScreen = true;
isFullScreenAnimationOn = false;
}
private void windowWillExitFullScreen() {
isFullScreenAnimationOn = true;
}
private void windowDidExitFullScreen() {
isInFullScreen = false;
isFullScreenAnimationOn = false;
}
}
private static void warning(String msg) {
PlatformLogger logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
logger.warning(msg);
}
final class XTextFieldPeer extends XComponentPeer implements TextFieldPeer {
private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XTextField");
private String text;
private final XAWTTextField xtext;
private final boolean firstChangeSkipped;
XTextFieldPeer(TextField target) {
super(target);
text = target.getText();
xtext = new XAWTTextField(text, this, target.getParent());
xtext.getDocument().addDocumentListener(xtext);
xtext.setCursor(target.getCursor());
XToolkit.specialPeerMap.put(xtext, this);
initTextField();
setText(target.getText());
if (target.echoCharIsSet()) {
setEchoChar(target.getEchoChar());
} else setEchoChar((char) 0);
int start = target.getSelectionStart();
int end = target.getSelectionEnd();
// Fix for 5100200
// Restoring Motif behaviour
// Since the end position of the selected text can be greater than the length of the text,
// so we should set caret to max position of the text
setCaretPosition(Math.min(end, text.length()));
if (end > start) {
// Should be called after setText() and setCaretPosition()
select(start, end);
}
setEditable(target.isEditable());
// After this line we should not change the component's text
firstChangeSkipped = true;
AWTAccessor.getComponentAccessor().setPeer(xtext, this);
}
@Override
public void dispose() {
XToolkit.specialPeerMap.remove(xtext);
// visible caret has a timer thread which must be stopped
xtext.getCaret().setVisible(false);
super.dispose();
}
void initTextField() {
setVisible(target.isVisible());
setBounds(x, y, width, height, SET_BOUNDS);
AWTAccessor.ComponentAccessor compAccessor = AWTAccessor.getComponentAccessor();
foreground = compAccessor.getForeground(target);
if (foreground == null) foreground = SystemColor.textText;
setForeground(foreground);
background = compAccessor.getBackground(target);
if (background == null) {
if (((TextField) target).isEditable()) background = SystemColor.text;
else background = SystemColor.control;
}
setBackground(background);
if (!target.isBackgroundSet()) {
// This is a way to set the background color of the TextArea
// without calling setBackground - go through accessor
compAccessor.setBackground(target, background);
}
if (!target.isForegroundSet()) {
target.setForeground(SystemColor.textText);
}
setFont(font);
}
/** @see java.awt.peer.TextComponentPeer */
@Override
public void setEditable(boolean editable) {
if (xtext != null) {
xtext.setEditable(editable);
xtext.repaint();
}
}
/** @see java.awt.peer.ComponentPeer */
@Override
public void setEnabled(boolean enabled) {
super.setEnabled(enabled);
if (xtext != null) {
xtext.setEnabled(enabled);
xtext.repaint();
}
}
/** @see java.awt.peer.TextComponentPeer */
@Override
public InputMethodRequests getInputMethodRequests() {
if (xtext != null) return xtext.getInputMethodRequests();
else return null;
}
@Override
void handleJavaInputMethodEvent(InputMethodEvent e) {
if (xtext != null) xtext.processInputMethodEventImpl(e);
}
/** @see java.awt.peer.TextFieldPeer */
@Override
public void setEchoChar(char c) {
if (xtext != null) {
xtext.setEchoChar(c);
xtext.putClientProperty(
"JPasswordField.cutCopyAllowed", xtext.echoCharIsSet() ? Boolean.FALSE : Boolean.TRUE);
}
}
/** @see java.awt.peer.TextComponentPeer */
@Override
public int getSelectionStart() {
return xtext.getSelectionStart();
}
/** @see java.awt.peer.TextComponentPeer */
@Override
public int getSelectionEnd() {
return xtext.getSelectionEnd();
}
/** @see java.awt.peer.TextComponentPeer */
@Override
@SuppressWarnings("deprecation")
public String getText() {
return xtext.getText();
}
/** @see java.awt.peer.TextComponentPeer */
@Override
public void setText(String text) {
setXAWTTextField(text);
repaint();
}
private void setXAWTTextField(String txt) {
text = txt;
if (xtext != null) {
// JTextField.setText() posts two different events (remove & insert).
// Since we make no differences between text events,
// the document listener has to be disabled while
// JTextField.setText() is called.
xtext.getDocument().removeDocumentListener(xtext);
xtext.setText(txt);
if (firstChangeSkipped) {
postEvent(new TextEvent(target, TextEvent.TEXT_VALUE_CHANGED));
}
xtext.getDocument().addDocumentListener(xtext);
xtext.setCaretPosition(0);
}
}
/**
* to be implemented.
*
* @see java.awt.peer.TextComponentPeer
*/
@Override
public void setCaretPosition(int position) {
if (xtext != null) xtext.setCaretPosition(position);
}
void repaintText() {
xtext.repaintNow();
}
@Override
public void setBackground(Color c) {
if (log.isLoggable(PlatformLogger.Level.FINE)) {
log.fine("target=" + target + ", old=" + background + ", new=" + c);
}
background = c;
if (xtext != null) {
if (xtext.getBackground() != c) {
xtext.setBackground(c);
}
xtext.setSelectedTextColor(c);
}
repaintText();
}
@Override
public void setForeground(Color c) {
foreground = c;
if (xtext != null) {
if (xtext.getForeground() != c) {
xtext.setForeground(foreground);
}
xtext.setSelectionColor(foreground);
xtext.setCaretColor(foreground);
}
repaintText();
}
@Override
public void setFont(Font f) {
synchronized (getStateLock()) {
font = f;
if (xtext != null && xtext.getFont() != f) {
xtext.setFont(font);
}
}
xtext.validate();
}
/** Deselects the highlighted text. */
public void deselect() {
int selStart = xtext.getSelectionStart();
int selEnd = xtext.getSelectionEnd();
if (selStart != selEnd) {
xtext.select(selStart, selStart);
}
}
/**
* to be implemented.
*
* @see java.awt.peer.TextComponentPeer
*/
@Override
public int getCaretPosition() {
return xtext.getCaretPosition();
}
/** @see java.awt.peer.TextComponentPeer */
@Override
public void select(int s, int e) {
xtext.select(s, e);
// Fixed 5100806
// We must take care that Swing components repainted correctly
xtext.repaint();
}
@Override
public Dimension getMinimumSize() {
return xtext.getMinimumSize();
}
@Override
public Dimension getPreferredSize() {
return xtext.getPreferredSize();
}
@Override
public Dimension getPreferredSize(int cols) {
return getMinimumSize(cols);
}
private static final int PADDING = 16;
@Override
public Dimension getMinimumSize(int cols) {
Font f = xtext.getFont();
FontMetrics fm = xtext.getFontMetrics(f);
return new Dimension(
fm.charWidth('0') * cols + 10, fm.getMaxDescent() + fm.getMaxAscent() + PADDING);
}
@Override
public boolean isFocusable() {
return true;
}
// NOTE: This method is called by privileged threads.
// DO NOT INVOKE CLIENT CODE ON THIS THREAD!
public void action(final long when, final int modifiers) {
postEvent(new ActionEvent(target, ActionEvent.ACTION_PERFORMED, text, when, modifiers));
}
protected void disposeImpl() {}
@Override
public void repaint() {
if (xtext != null) xtext.repaint();
}
@Override
void paintPeer(final Graphics g) {
if (xtext != null) xtext.paint(g);
}
@Override
public void print(Graphics g) {
if (xtext != null) {
xtext.print(g);
}
}
@Override
public void focusLost(FocusEvent e) {
super.focusLost(e);
xtext.forwardFocusLost(e);
}
@Override
public void focusGained(FocusEvent e) {
super.focusGained(e);
xtext.forwardFocusGained(e);
}
@Override
void handleJavaKeyEvent(KeyEvent e) {
AWTAccessor.getComponentAccessor().processEvent(xtext, e);
}
@Override
public void handleJavaMouseEvent(MouseEvent mouseEvent) {
super.handleJavaMouseEvent(mouseEvent);
if (xtext != null) {
mouseEvent.setSource(xtext);
int id = mouseEvent.getID();
if (id == MouseEvent.MOUSE_DRAGGED || id == MouseEvent.MOUSE_MOVED)
xtext.processMouseMotionEventImpl(mouseEvent);
else xtext.processMouseEventImpl(mouseEvent);
}
}
/** DEPRECATED */
@Override
public Dimension minimumSize() {
return getMinimumSize();
}
@Override
public void setVisible(boolean b) {
super.setVisible(b);
if (xtext != null) xtext.setVisible(b);
}
@Override
public void setBounds(int x, int y, int width, int height, int op) {
super.setBounds(x, y, width, height, op);
if (xtext != null) {
/*
* Fixed 6277332, 6198290:
* the coordinates is coming (to peer): relatively to closest HW parent
* the coordinates is setting (to textField): relatively to closest ANY parent
* the parent of peer is target.getParent()
* the parent of textField is the same
* see 6277332, 6198290 for more information
*/
int childX = x;
int childY = y;
Component parent = target.getParent();
// we up to heavyweight parent in order to be sure
// that the coordinates of the text pane is relatively to closest parent
while (parent.isLightweight()) {
childX -= parent.getX();
childY -= parent.getY();
parent = parent.getParent();
}
xtext.setBounds(childX, childY, width, height);
xtext.validate();
}
}
final class AWTTextFieldUI extends MotifPasswordFieldUI {
private JTextField jtf;
@Override
protected String getPropertyPrefix() {
JTextComponent comp = getComponent();
if (comp instanceof JPasswordField && ((JPasswordField) comp).echoCharIsSet()) {
return "PasswordField";
} else {
return "TextField";
}
}
@Override
public void installUI(JComponent c) {
super.installUI(c);
jtf = (JTextField) c;
JTextField editor = jtf;
UIDefaults uidefaults = XToolkit.getUIDefaults();
String prefix = getPropertyPrefix();
Font f = editor.getFont();
if ((f == null) || (f instanceof UIResource)) {
editor.setFont(uidefaults.getFont(prefix + ".font"));
}
Color bg = editor.getBackground();
if ((bg == null) || (bg instanceof UIResource)) {
editor.setBackground(uidefaults.getColor(prefix + ".background"));
}
Color fg = editor.getForeground();
if ((fg == null) || (fg instanceof UIResource)) {
editor.setForeground(uidefaults.getColor(prefix + ".foreground"));
}
Color color = editor.getCaretColor();
if ((color == null) || (color instanceof UIResource)) {
editor.setCaretColor(uidefaults.getColor(prefix + ".caretForeground"));
}
Color s = editor.getSelectionColor();
if ((s == null) || (s instanceof UIResource)) {
editor.setSelectionColor(uidefaults.getColor(prefix + ".selectionBackground"));
}
Color sfg = editor.getSelectedTextColor();
if ((sfg == null) || (sfg instanceof UIResource)) {
editor.setSelectedTextColor(uidefaults.getColor(prefix + ".selectionForeground"));
}
Color dfg = editor.getDisabledTextColor();
if ((dfg == null) || (dfg instanceof UIResource)) {
editor.setDisabledTextColor(uidefaults.getColor(prefix + ".inactiveForeground"));
}
Border b = editor.getBorder();
if ((b == null) || (b instanceof UIResource)) {
editor.setBorder(uidefaults.getBorder(prefix + ".border"));
}
Insets margin = editor.getMargin();
if (margin == null || margin instanceof UIResource) {
editor.setMargin(uidefaults.getInsets(prefix + ".margin"));
}
}
@Override
protected void installKeyboardActions() {
super.installKeyboardActions();
JTextComponent comp = getComponent();
UIDefaults uidefaults = XToolkit.getUIDefaults();
String prefix = getPropertyPrefix();
InputMap map = (InputMap) uidefaults.get(prefix + ".focusInputMap");
if (map != null) {
SwingUtilities.replaceUIInputMap(comp, JComponent.WHEN_FOCUSED, map);
}
}
@Override
protected Caret createCaret() {
return new XTextAreaPeer.XAWTCaret();
}
}
@SuppressWarnings("serial") // JDK-implementation class
final class XAWTTextField extends JPasswordField implements ActionListener, DocumentListener {
private boolean isFocused = false;
private final XComponentPeer xwin;
XAWTTextField(String text, XComponentPeer xwin, Container parent) {
super(text);
this.xwin = xwin;
setDoubleBuffered(true);
setFocusable(false);
AWTAccessor.getComponentAccessor().setParent(this, parent);
setBackground(xwin.getPeerBackground());
setForeground(xwin.getPeerForeground());
setFont(xwin.getPeerFont());
setCaretPosition(0);
addActionListener(this);
addNotify();
}
@Override
@SuppressWarnings("deprecation")
public void actionPerformed(ActionEvent actionEvent) {
xwin.postEvent(
new ActionEvent(
xwin.target,
ActionEvent.ACTION_PERFORMED,
getText(),
actionEvent.getWhen(),
actionEvent.getModifiers()));
}
@Override
public void insertUpdate(DocumentEvent e) {
if (xwin != null) {
xwin.postEvent(new TextEvent(xwin.target, TextEvent.TEXT_VALUE_CHANGED));
}
}
@Override
public void removeUpdate(DocumentEvent e) {
if (xwin != null) {
xwin.postEvent(new TextEvent(xwin.target, TextEvent.TEXT_VALUE_CHANGED));
}
}
@Override
public void changedUpdate(DocumentEvent e) {
if (xwin != null) {
xwin.postEvent(new TextEvent(xwin.target, TextEvent.TEXT_VALUE_CHANGED));
}
}
public void repaintNow() {
paintImmediately(getBounds());
}
@Override
public Graphics getGraphics() {
return xwin.getGraphics();
}
@Override
public void updateUI() {
ComponentUI ui = new AWTTextFieldUI();
setUI(ui);
}
void forwardFocusGained(FocusEvent e) {
isFocused = true;
FocusEvent fe =
new FocusEvent(this, e.getID(), e.isTemporary(), e.getOppositeComponent(), e.getCause());
super.processFocusEvent(fe);
}
void forwardFocusLost(FocusEvent e) {
isFocused = false;
FocusEvent fe =
new FocusEvent(this, e.getID(), e.isTemporary(), e.getOppositeComponent(), e.getCause());
super.processFocusEvent(fe);
}
@Override
public boolean hasFocus() {
return isFocused;
}
public void processInputMethodEventImpl(InputMethodEvent e) {
processInputMethodEvent(e);
}
public void processMouseEventImpl(MouseEvent e) {
processMouseEvent(e);
}
public void processMouseMotionEventImpl(MouseEvent e) {
processMouseMotionEvent(e);
}
// Fix for 4915454 - override the default implementation to avoid
// loading SystemFlavorMap and associated classes.
@Override
public void setTransferHandler(TransferHandler newHandler) {
TransferHandler oldHandler =
(TransferHandler)
getClientProperty(
AWTAccessor.getClientPropertyKeyAccessor().getJComponent_TRANSFER_HANDLER());
putClientProperty(
AWTAccessor.getClientPropertyKeyAccessor().getJComponent_TRANSFER_HANDLER(), newHandler);
firePropertyChange("transferHandler", oldHandler, newHandler);
}
@Override
public void setEchoChar(char c) {
super.setEchoChar(c);
((AWTTextFieldUI) ui).installKeyboardActions();
}
}
}
public class XEmbedCanvasPeer extends XCanvasPeer
implements WindowFocusListener, KeyEventPostProcessor, ModalityListener, WindowIDProvider {
private static final PlatformLogger xembedLog =
PlatformLogger.getLogger("sun.awt.X11.xembed.XEmbedCanvasPeer");
boolean applicationActive; // Whether the application is active(has focus)
XEmbedServer xembed = new XEmbedServer(); // Helper object, contains XEmbed intrinsics
Map<Long, AWTKeyStroke> accelerators =
new HashMap<Long, AWTKeyStroke>(); // Maps accelerator ID into AWTKeyStroke
Map<AWTKeyStroke, Long> accel_lookup =
new HashMap<AWTKeyStroke, Long>(); // Maps AWTKeyStroke into accelerator ID
Set<GrabbedKey> grabbed_keys = new HashSet<GrabbedKey>(); // A set of keys grabbed by client
Object ACCEL_LOCK = accelerators; // Lock object for working with accelerators;
Object GRAB_LOCK = grabbed_keys; // Lock object for working with keys grabbed by client
XEmbedCanvasPeer() {}
XEmbedCanvasPeer(XCreateWindowParams params) {
super(params);
}
XEmbedCanvasPeer(Component target) {
super(target);
}
protected void postInit(XCreateWindowParams params) {
super.postInit(params);
installActivateListener();
installAcceleratorListener();
installModalityListener();
// XEmbed canvas should be non-traversable.
// FIXME: Probably should be removed and enforced setting of it by the users
target.setFocusTraversalKeysEnabled(false);
}
protected void preInit(XCreateWindowParams params) {
super.preInit(params);
params.put(
EVENT_MASK,
XConstants.KeyPressMask
| XConstants.KeyReleaseMask
| XConstants.FocusChangeMask
| XConstants.ButtonPressMask
| XConstants.ButtonReleaseMask
| XConstants.EnterWindowMask
| XConstants.LeaveWindowMask
| XConstants.PointerMotionMask
| XConstants.ButtonMotionMask
| XConstants.ExposureMask
| XConstants.StructureNotifyMask
| XConstants.SubstructureNotifyMask);
}
void installModalityListener() {
((SunToolkit) Toolkit.getDefaultToolkit()).addModalityListener(this);
}
void deinstallModalityListener() {
((SunToolkit) Toolkit.getDefaultToolkit()).removeModalityListener(this);
}
void installAcceleratorListener() {
KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventPostProcessor(this);
}
void deinstallAcceleratorListener() {
KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventPostProcessor(this);
}
void installActivateListener() {
// FIXME: should watch for hierarchy changes
Window toplevel = getTopLevel(target);
if (toplevel != null) {
toplevel.addWindowFocusListener(this);
applicationActive = toplevel.isFocused();
}
}
void deinstallActivateListener() {
Window toplevel = getTopLevel(target);
if (toplevel != null) {
toplevel.removeWindowFocusListener(this);
}
}
boolean isXEmbedActive() {
return xembed.handle != 0;
}
boolean isApplicationActive() {
return applicationActive;
}
void initDispatching() {
if (xembedLog.isLoggable(PlatformLogger.FINE))
xembedLog.fine("Init embedding for " + Long.toHexString(xembed.handle));
XToolkit.awtLock();
try {
XToolkit.addEventDispatcher(xembed.handle, xembed);
XlibWrapper.XSelectInput(
XToolkit.getDisplay(),
xembed.handle,
XConstants.StructureNotifyMask | XConstants.PropertyChangeMask);
XDropTargetRegistry.getRegistry().registerXEmbedClient(getWindow(), xembed.handle);
} finally {
XToolkit.awtUnlock();
}
xembed.processXEmbedInfo();
notifyChildEmbedded();
}
void endDispatching() {
xembedLog.fine("End dispatching for " + Long.toHexString(xembed.handle));
XToolkit.awtLock();
try {
XDropTargetRegistry.getRegistry().unregisterXEmbedClient(getWindow(), xembed.handle);
// We can't deselect input since someone else might be interested in it
XToolkit.removeEventDispatcher(xembed.handle, xembed);
} finally {
XToolkit.awtUnlock();
}
}
void embedChild(long child) {
if (xembed.handle != 0) {
detachChild();
}
xembed.handle = child;
initDispatching();
}
void childDestroyed() {
xembedLog.fine("Child " + Long.toHexString(xembed.handle) + " has self-destroyed.");
endDispatching();
xembed.handle = 0;
}
public void handleEvent(AWTEvent e) {
super.handleEvent(e);
if (isXEmbedActive()) {
switch (e.getID()) {
case FocusEvent.FOCUS_GAINED:
canvasFocusGained((FocusEvent) e);
break;
case FocusEvent.FOCUS_LOST:
canvasFocusLost((FocusEvent) e);
break;
case KeyEvent.KEY_PRESSED:
case KeyEvent.KEY_RELEASED:
if (!((InputEvent) e).isConsumed()) {
forwardKeyEvent((KeyEvent) e);
}
break;
}
}
}
public void dispatchEvent(XEvent ev) {
super.dispatchEvent(ev);
switch (ev.get_type()) {
case XConstants.CreateNotify:
XCreateWindowEvent cr = ev.get_xcreatewindow();
if (xembedLog.isLoggable(PlatformLogger.FINEST)) {
xembedLog.finest("Message on embedder: " + cr);
}
if (xembedLog.isLoggable(PlatformLogger.FINER)) {
xembedLog.finer(
"Create notify for parent "
+ Long.toHexString(cr.get_parent())
+ ", window "
+ Long.toHexString(cr.get_window()));
}
embedChild(cr.get_window());
break;
case XConstants.DestroyNotify:
XDestroyWindowEvent dn = ev.get_xdestroywindow();
if (xembedLog.isLoggable(PlatformLogger.FINEST)) {
xembedLog.finest("Message on embedder: " + dn);
}
if (xembedLog.isLoggable(PlatformLogger.FINER)) {
xembedLog.finer("Destroy notify for parent: " + dn);
}
childDestroyed();
break;
case XConstants.ReparentNotify:
XReparentEvent rep = ev.get_xreparent();
if (xembedLog.isLoggable(PlatformLogger.FINEST)) {
xembedLog.finest("Message on embedder: " + rep);
}
if (xembedLog.isLoggable(PlatformLogger.FINER)) {
xembedLog.finer(
"Reparent notify for parent "
+ Long.toHexString(rep.get_parent())
+ ", window "
+ Long.toHexString(rep.get_window())
+ ", event "
+ Long.toHexString(rep.get_event()));
}
if (rep.get_parent() == getWindow()) {
// Reparented into us - embed it
embedChild(rep.get_window());
} else {
// Reparented out of us - detach it
childDestroyed();
}
break;
}
}
public Dimension getPreferredSize() {
if (isXEmbedActive()) {
XToolkit.awtLock();
try {
long p_hints = XlibWrapper.XAllocSizeHints();
XSizeHints hints = new XSizeHints(p_hints);
XlibWrapper.XGetWMNormalHints(
XToolkit.getDisplay(), xembed.handle, p_hints, XlibWrapper.larg1);
Dimension res = new Dimension(hints.get_width(), hints.get_height());
XlibWrapper.XFree(p_hints);
return res;
} finally {
XToolkit.awtUnlock();
}
} else {
return super.getPreferredSize();
}
}
public Dimension getMinimumSize() {
if (isXEmbedActive()) {
XToolkit.awtLock();
try {
long p_hints = XlibWrapper.XAllocSizeHints();
XSizeHints hints = new XSizeHints(p_hints);
XlibWrapper.XGetWMNormalHints(
XToolkit.getDisplay(), xembed.handle, p_hints, XlibWrapper.larg1);
Dimension res = new Dimension(hints.get_min_width(), hints.get_min_height());
XlibWrapper.XFree(p_hints);
return res;
} finally {
XToolkit.awtUnlock();
}
} else {
return super.getMinimumSize();
}
}
public void dispose() {
if (isXEmbedActive()) {
detachChild();
}
deinstallActivateListener();
deinstallModalityListener();
deinstallAcceleratorListener();
// BUG: Focus traversal doesn't become enabled after the one round of embedding
// target.setFocusTraversalKeysEnabled(true);
super.dispose();
}
// Focusable is true in order to enable focus traversal through this Canvas
public boolean isFocusable() {
return true;
}
Window getTopLevel(Component comp) {
while (comp != null && !(comp instanceof Window)) {
comp = comp.getParent();
}
return (Window) comp;
}
Rectangle getClientBounds() {
XToolkit.awtLock();
try {
XWindowAttributes wattr = new XWindowAttributes();
try {
XToolkit.WITH_XERROR_HANDLER(XErrorHandler.IgnoreBadWindowHandler.getInstance());
int status =
XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(), xembed.handle, wattr.pData);
XToolkit.RESTORE_XERROR_HANDLER();
if (status == 0
|| (XToolkit.saved_error != null
&& XToolkit.saved_error.get_error_code() != XConstants.Success)) {
return null;
}
return new Rectangle(wattr.get_x(), wattr.get_y(), wattr.get_width(), wattr.get_height());
} finally {
wattr.dispose();
}
} finally {
XToolkit.awtUnlock();
}
}
void childResized() {
if (xembedLog.isLoggable(PlatformLogger.FINER)) {
Rectangle bounds = getClientBounds();
xembedLog.finer("Child resized: " + bounds);
// It is not required to update embedder's size when client size changes
// However, since there is no any means to get client size it seems to be the
// only way to provide it. However, it contradicts with Java layout concept -
// so it is disabled for now.
// Rectangle my_bounds = getBounds();
// setBounds(my_bounds.x, my_bounds.y, bounds.width, bounds.height, SET_BOUNDS);
}
XToolkit.postEvent(
XToolkit.targetToAppContext(target),
new ComponentEvent(target, ComponentEvent.COMPONENT_RESIZED));
}
void focusNext() {
if (isXEmbedActive()) {
xembedLog.fine("Requesting focus for the next component after embedder");
postEvent(
new InvocationEvent(
target,
new Runnable() {
public void run() {
KeyboardFocusManager.getCurrentKeyboardFocusManager().focusNextComponent(target);
}
}));
} else {
xembedLog.fine("XEmbed is not active - denying focus next");
}
}
void focusPrev() {
if (isXEmbedActive()) {
xembedLog.fine("Requesting focus for the next component after embedder");
postEvent(
new InvocationEvent(
target,
new Runnable() {
public void run() {
KeyboardFocusManager.getCurrentKeyboardFocusManager()
.focusPreviousComponent(target);
}
}));
} else {
xembedLog.fine("XEmbed is not active - denying focus prev");
}
}
void requestXEmbedFocus() {
if (isXEmbedActive()) {
xembedLog.fine("Requesting focus for client");
postEvent(
new InvocationEvent(
target,
new Runnable() {
public void run() {
target.requestFocus();
}
}));
} else {
xembedLog.fine("XEmbed is not active - denying request focus");
}
}
void notifyChildEmbedded() {
xembed.sendMessage(
xembed.handle,
XEMBED_EMBEDDED_NOTIFY,
getWindow(),
Math.min(xembed.version, XEMBED_VERSION),
0);
if (isApplicationActive()) {
xembedLog.fine("Sending WINDOW_ACTIVATE during initialization");
xembed.sendMessage(xembed.handle, XEMBED_WINDOW_ACTIVATE);
if (hasFocus()) {
xembedLog.fine("Sending FOCUS_GAINED during initialization");
xembed.sendMessage(xembed.handle, XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT, 0, 0);
}
}
}
void detachChild() {
if (xembedLog.isLoggable(PlatformLogger.FINE))
xembedLog.fine("Detaching child " + Long.toHexString(xembed.handle));
/**
* XEmbed specification: "The embedder can unmap the client and reparent the client window to
* the root window. If the client receives an ReparentNotify event, it should check the parent
* field of the XReparentEvent structure. If this is the root window of the window's screen,
* then the protocol is finished and there is no further interaction. If it is a window other
* than the root window, then the protocol continues with the new parent acting as the embedder
* window."
*/
XToolkit.awtLock();
try {
XlibWrapper.XUnmapWindow(XToolkit.getDisplay(), xembed.handle);
XlibWrapper.XReparentWindow(
XToolkit.getDisplay(), xembed.handle, XToolkit.getDefaultRootWindow(), 0, 0);
} finally {
XToolkit.awtUnlock();
}
endDispatching();
xembed.handle = 0;
}
public void windowGainedFocus(WindowEvent e) {
applicationActive = true;
if (isXEmbedActive()) {
xembedLog.fine("Sending WINDOW_ACTIVATE");
xembed.sendMessage(xembed.handle, XEMBED_WINDOW_ACTIVATE);
}
}
public void windowLostFocus(WindowEvent e) {
applicationActive = false;
if (isXEmbedActive()) {
xembedLog.fine("Sending WINDOW_DEACTIVATE");
xembed.sendMessage(xembed.handle, XEMBED_WINDOW_DEACTIVATE);
}
}
void canvasFocusGained(FocusEvent e) {
if (isXEmbedActive()) {
xembedLog.fine("Forwarding FOCUS_GAINED");
int flavor = XEMBED_FOCUS_CURRENT;
if (e instanceof CausedFocusEvent) {
CausedFocusEvent ce = (CausedFocusEvent) e;
if (ce.getCause() == CausedFocusEvent.Cause.TRAVERSAL_FORWARD) {
flavor = XEMBED_FOCUS_FIRST;
} else if (ce.getCause() == CausedFocusEvent.Cause.TRAVERSAL_BACKWARD) {
flavor = XEMBED_FOCUS_LAST;
}
}
xembed.sendMessage(xembed.handle, XEMBED_FOCUS_IN, flavor, 0, 0);
}
}
void canvasFocusLost(FocusEvent e) {
if (isXEmbedActive() && !e.isTemporary()) {
xembedLog.fine("Forwarding FOCUS_LOST");
int num = 0;
if (AccessController.doPrivileged(new GetBooleanAction("sun.awt.xembed.testing"))) {
Component opp = e.getOppositeComponent();
try {
num = Integer.parseInt(opp.getName());
} catch (NumberFormatException nfe) {
}
}
xembed.sendMessage(xembed.handle, XEMBED_FOCUS_OUT, num, 0, 0);
}
}
static Field bdataField;
static byte[] getBData(KeyEvent e) {
try {
if (bdataField == null) {
bdataField = SunToolkit.getField(java.awt.AWTEvent.class, "bdata");
}
return (byte[]) bdataField.get(e);
} catch (IllegalAccessException ex) {
return null;
}
}
void forwardKeyEvent(KeyEvent e) {
xembedLog.fine("Try to forward key event");
byte[] bdata = getBData(e);
long data = Native.toData(bdata);
if (data == 0) {
return;
}
try {
XKeyEvent ke = new XKeyEvent(data);
ke.set_window(xembed.handle);
if (xembedLog.isLoggable(PlatformLogger.FINE))
xembedLog.fine("Forwarding native key event: " + ke);
XToolkit.awtLock();
try {
XlibWrapper.XSendEvent(
XToolkit.getDisplay(), xembed.handle, false, XConstants.NoEventMask, data);
} finally {
XToolkit.awtUnlock();
}
} finally {
XlibWrapper.unsafe.freeMemory(data);
}
}
/**
* Grab/ungrab key functionality is an unofficial API supported by GTK. Unfortunately, it doesn't
* support accelerator API, so, since this is the ONLY shortcut-processing API available, we must
* support it. See XEmbed.NON_STANDARD_XEMBED_GTK_* messages. The format of these messages is as
* follows: - request from client: data[1] = NON_STANDARD_XEMBED_GTK_GRAB_KEY or
* NON_STANDARD_XEMBED_GTK_UNGRAB_KEY data[3] = X keysym data[4] = X modifiers
*
* <p>- response from server (in case the grabbed key has been pressed): forwarded XKeyEvent that
* matches keysym/modifiers pair
*/
void grabKey(final long keysym, final long modifiers) {
postEvent(
new InvocationEvent(
target,
new Runnable() {
public void run() {
GrabbedKey grab = new GrabbedKey(keysym, modifiers);
if (xembedLog.isLoggable(PlatformLogger.FINE))
xembedLog.fine("Grabbing key: " + grab);
synchronized (GRAB_LOCK) {
grabbed_keys.add(grab);
}
}
}));
}
void ungrabKey(final long keysym, final long modifiers) {
postEvent(
new InvocationEvent(
target,
new Runnable() {
public void run() {
GrabbedKey grab = new GrabbedKey(keysym, modifiers);
if (xembedLog.isLoggable(PlatformLogger.FINE))
xembedLog.fine("UnGrabbing key: " + grab);
synchronized (GRAB_LOCK) {
grabbed_keys.remove(grab);
}
}
}));
}
void registerAccelerator(final long accel_id, final long keysym, final long modifiers) {
postEvent(
new InvocationEvent(
target,
new Runnable() {
public void run() {
AWTKeyStroke stroke = xembed.getKeyStrokeForKeySym(keysym, modifiers);
if (stroke != null) {
if (xembedLog.isLoggable(PlatformLogger.FINE))
xembedLog.fine("Registering accelerator " + accel_id + " for " + stroke);
synchronized (ACCEL_LOCK) {
accelerators.put(accel_id, stroke);
accel_lookup.put(stroke, accel_id);
}
}
propogateRegisterAccelerator(stroke);
}
}));
}
void unregisterAccelerator(final long accel_id) {
postEvent(
new InvocationEvent(
target,
new Runnable() {
public void run() {
AWTKeyStroke stroke = null;
synchronized (ACCEL_LOCK) {
stroke = accelerators.get(accel_id);
if (stroke != null) {
if (xembedLog.isLoggable(PlatformLogger.FINE))
xembedLog.fine("Unregistering accelerator: " + accel_id);
accelerators.remove(accel_id);
accel_lookup.remove(
stroke); // FIXME: How about several accelerators with the same stroke?
}
}
propogateUnRegisterAccelerator(stroke);
}
}));
}
void propogateRegisterAccelerator(AWTKeyStroke stroke) {
// Find the top-level and see if it is XEmbed client. If so, ask him to
// register the accelerator
XWindowPeer parent = getToplevelXWindow();
if (parent != null && parent instanceof XEmbeddedFramePeer) {
XEmbeddedFramePeer embedded = (XEmbeddedFramePeer) parent;
embedded.registerAccelerator(stroke);
}
}
void propogateUnRegisterAccelerator(AWTKeyStroke stroke) {
// Find the top-level and see if it is XEmbed client. If so, ask him to
// register the accelerator
XWindowPeer parent = getToplevelXWindow();
if (parent != null && parent instanceof XEmbeddedFramePeer) {
XEmbeddedFramePeer embedded = (XEmbeddedFramePeer) parent;
embedded.unregisterAccelerator(stroke);
}
}
public boolean postProcessKeyEvent(KeyEvent e) {
// Processing events only if we are in the focused window but
// we are not focus owner since otherwise we will get
// duplicate shortcut events in the client - one is from
// activate_accelerator, another from forwarded event
// FIXME: This is probably an incompatibility, protocol
// doesn't say anything about disable accelerators when client
// is focused.
XWindowPeer parent = getToplevelXWindow();
if (parent == null || !((Window) parent.getTarget()).isFocused() || target.isFocusOwner()) {
return false;
}
boolean result = false;
if (xembedLog.isLoggable(PlatformLogger.FINER)) xembedLog.finer("Post-processing event " + e);
// Process ACCELERATORS
AWTKeyStroke stroke = AWTKeyStroke.getAWTKeyStrokeForEvent(e);
long accel_id = 0;
boolean exists = false;
synchronized (ACCEL_LOCK) {
exists = accel_lookup.containsKey(stroke);
if (exists) {
accel_id = accel_lookup.get(stroke).longValue();
}
}
if (exists) {
if (xembedLog.isLoggable(PlatformLogger.FINE))
xembedLog.fine("Activating accelerator " + accel_id);
xembed.sendMessage(
xembed.handle,
XEMBED_ACTIVATE_ACCELERATOR,
accel_id,
0,
0); // FIXME: How about overloaded?
result = true;
}
// Process Grabs, unofficial GTK feature
exists = false;
GrabbedKey key = new GrabbedKey(e);
synchronized (GRAB_LOCK) {
exists = grabbed_keys.contains(key);
}
if (exists) {
if (xembedLog.isLoggable(PlatformLogger.FINE)) xembedLog.fine("Forwarding grabbed key " + e);
forwardKeyEvent(e);
result = true;
}
return result;
}
public void modalityPushed(ModalityEvent ev) {
xembed.sendMessage(xembed.handle, XEMBED_MODALITY_ON);
}
public void modalityPopped(ModalityEvent ev) {
xembed.sendMessage(xembed.handle, XEMBED_MODALITY_OFF);
}
public void handleClientMessage(XEvent xev) {
super.handleClientMessage(xev);
XClientMessageEvent msg = xev.get_xclient();
if (xembedLog.isLoggable(PlatformLogger.FINER))
xembedLog.finer("Client message to embedder: " + msg);
if (msg.get_message_type() == xembed.XEmbed.getAtom()) {
if (xembedLog.isLoggable(PlatformLogger.FINE))
xembedLog.fine(xembed.XEmbedMessageToString(msg));
}
if (isXEmbedActive()) {
switch ((int) msg.get_data(1)) {
case XEMBED_REQUEST_FOCUS:
requestXEmbedFocus();
break;
case XEMBED_FOCUS_NEXT:
focusNext();
break;
case XEMBED_FOCUS_PREV:
focusPrev();
break;
case XEMBED_REGISTER_ACCELERATOR:
registerAccelerator(msg.get_data(2), msg.get_data(3), msg.get_data(4));
break;
case XEMBED_UNREGISTER_ACCELERATOR:
unregisterAccelerator(msg.get_data(2));
break;
case NON_STANDARD_XEMBED_GTK_GRAB_KEY:
grabKey(msg.get_data(3), msg.get_data(4));
break;
case NON_STANDARD_XEMBED_GTK_UNGRAB_KEY:
ungrabKey(msg.get_data(3), msg.get_data(4));
break;
}
} else {
xembedLog.finer("But XEmbed is not Active!");
}
}
private static class XEmbedDropTarget extends DropTarget {
public void addDropTargetListener(DropTargetListener dtl) throws TooManyListenersException {
// Drop target listeners registered with this target will never be
// notified, since all drag notifications are routed to the XEmbed
// client. To avoid confusion we prohibit listeners registration
// by throwing TooManyListenersException as if there is a listener
// registered with this target already.
throw new TooManyListenersException();
}
}
public void setXEmbedDropTarget() {
// Register a drop site on the top level.
Runnable r =
new Runnable() {
public void run() {
target.setDropTarget(new XEmbedDropTarget());
}
};
SunToolkit.executeOnEventHandlerThread(target, r);
}
public void removeXEmbedDropTarget() {
// Unregister a drop site on the top level.
Runnable r =
new Runnable() {
public void run() {
if (target.getDropTarget() instanceof XEmbedDropTarget) {
target.setDropTarget(null);
}
}
};
SunToolkit.executeOnEventHandlerThread(target, r);
}
public boolean processXEmbedDnDEvent(long ctxt, int eventID) {
if (xembedLog.isLoggable(PlatformLogger.FINEST)) {
xembedLog.finest(" Drop target=" + target.getDropTarget());
}
if (target.getDropTarget() instanceof XEmbedDropTarget) {
AppContext appContext = XToolkit.targetToAppContext(getTarget());
XDropTargetContextPeer peer = XDropTargetContextPeer.getPeer(appContext);
peer.forwardEventToEmbedded(xembed.handle, ctxt, eventID);
return true;
} else {
return false;
}
}
class XEmbedServer extends XEmbedHelper implements XEventDispatcher {
long handle; // Handle to XEmbed client
long version;
long flags;
boolean processXEmbedInfo() {
long xembed_info_data = Native.allocateLongArray(2);
try {
if (!XEmbedInfo.getAtomData(handle, xembed_info_data, 2)) {
// No more XEMBED_INFO? This is not XEmbed client!
// Unfortunately this is the initial state of the most clients
// FIXME: add 5-state processing
// childDestroyed();
xembedLog.finer("Unable to get XEMBED_INFO atom data");
return false;
}
version = Native.getCard32(xembed_info_data, 0);
flags = Native.getCard32(xembed_info_data, 1);
boolean new_mapped = (flags & XEMBED_MAPPED) != 0;
boolean currently_mapped = XlibUtil.getWindowMapState(handle) != XConstants.IsUnmapped;
if (new_mapped != currently_mapped) {
if (xembedLog.isLoggable(PlatformLogger.FINER))
xembedLog.fine(
"Mapping state of the client has changed, old state: "
+ currently_mapped
+ ", new state: "
+ new_mapped);
if (new_mapped) {
XToolkit.awtLock();
try {
XlibWrapper.XMapWindow(XToolkit.getDisplay(), handle);
} finally {
XToolkit.awtUnlock();
}
} else {
XToolkit.awtLock();
try {
XlibWrapper.XUnmapWindow(XToolkit.getDisplay(), handle);
} finally {
XToolkit.awtUnlock();
}
}
} else {
xembedLog.finer("Mapping state didn't change, mapped: " + currently_mapped);
}
return true;
} finally {
XlibWrapper.unsafe.freeMemory(xembed_info_data);
}
}
public void handlePropertyNotify(XEvent xev) {
if (isXEmbedActive()) {
XPropertyEvent ev = xev.get_xproperty();
if (xembedLog.isLoggable(PlatformLogger.FINER))
xembedLog.finer("Property change on client: " + ev);
if (ev.get_atom() == XAtom.XA_WM_NORMAL_HINTS) {
childResized();
} else if (ev.get_atom() == XEmbedInfo.getAtom()) {
processXEmbedInfo();
} else if (ev.get_atom() == XDnDConstants.XA_XdndAware.getAtom()) {
XDropTargetRegistry.getRegistry().unregisterXEmbedClient(getWindow(), xembed.handle);
if (ev.get_state() == XConstants.PropertyNewValue) {
XDropTargetRegistry.getRegistry().registerXEmbedClient(getWindow(), xembed.handle);
}
}
} else {
xembedLog.finer("XEmbed is not active");
}
}
void handleConfigureNotify(XEvent xev) {
if (isXEmbedActive()) {
XConfigureEvent ev = xev.get_xconfigure();
if (xembedLog.isLoggable(PlatformLogger.FINER))
xembedLog.finer("Bounds change on client: " + ev);
if (xev.get_xany().get_window() == handle) {
childResized();
}
}
}
public void dispatchEvent(XEvent xev) {
int type = xev.get_type();
switch (type) {
case XConstants.PropertyNotify:
handlePropertyNotify(xev);
break;
case XConstants.ConfigureNotify:
handleConfigureNotify(xev);
break;
case XConstants.ClientMessage:
handleClientMessage(xev);
break;
}
}
}
static class GrabbedKey {
long keysym;
long modifiers;
GrabbedKey(long keysym, long modifiers) {
this.keysym = keysym;
this.modifiers = modifiers;
}
GrabbedKey(KeyEvent ev) {
init(ev);
}
private void init(KeyEvent e) {
byte[] bdata = getBData(e);
long data = Native.toData(bdata);
if (data == 0) {
return;
}
try {
XToolkit.awtLock();
try {
keysym = XWindow.getKeySymForAWTKeyCode(e.getKeyCode());
} finally {
XToolkit.awtUnlock();
}
XKeyEvent ke = new XKeyEvent(data);
// We recognize only these masks
modifiers =
ke.get_state() & (XConstants.ShiftMask | XConstants.ControlMask | XConstants.LockMask);
if (xembedLog.isLoggable(PlatformLogger.FINEST))
xembedLog.finest("Mapped " + e + " to " + this);
} finally {
XlibWrapper.unsafe.freeMemory(data);
}
}
public int hashCode() {
return (int) keysym & 0xFFFFFFFF;
}
public boolean equals(Object o) {
if (!(o instanceof GrabbedKey)) {
return false;
}
GrabbedKey key = (GrabbedKey) o;
return (keysym == key.keysym && modifiers == key.modifiers);
}
public String toString() {
return "Key combination[keysym=" + keysym + ", mods=" + modifiers + "]";
}
}
}
/**
* The AppContext is a table referenced by ThreadGroup which stores application service instances.
* (If you are not writing an application service, or don't know what one is, please do not use this
* class.) The AppContext allows applet access to what would otherwise be potentially dangerous
* services, such as the ability to peek at EventQueues or change the look-and-feel of a Swing
* application.
*
* <p>Most application services use a singleton object to provide their services, either as a
* default (such as getSystemEventQueue or getDefaultToolkit) or as static methods with class data
* (System). The AppContext works with the former method by extending the concept of "default" to be
* ThreadGroup-specific. Application services lookup their singleton in the AppContext.
*
* <p>For example, here we have a Foo service, with its pre-AppContext code:
*
* <p><code><pre>
* public class Foo {
* private static Foo defaultFoo = new Foo();
*
* public static Foo getDefaultFoo() {
* return defaultFoo;
* }
*
* ... Foo service methods
* }</pre></code>
*
* <p>The problem with the above is that the Foo service is global in scope, so that applets and
* other untrusted code can execute methods on the single, shared Foo instance. The Foo service
* therefore either needs to block its use by untrusted code using a SecurityManager test, or
* restrict its capabilities so that it doesn't matter if untrusted code executes it.
*
* <p>Here's the Foo class written to use the AppContext:
*
* <p><code><pre>
* public class Foo {
* public static Foo getDefaultFoo() {
* Foo foo = (Foo)AppContext.getAppContext().get(Foo.class);
* if (foo == null) {
* foo = new Foo();
* getAppContext().put(Foo.class, foo);
* }
* return foo;
* }
*
* ... Foo service methods
* }</pre></code>
*
* <p>Since a separate AppContext can exist for each ThreadGroup, trusted and untrusted code have
* access to different Foo instances. This allows untrusted code access to "system-wide" services --
* the service remains within the AppContext "sandbox". For example, say a malicious applet wants to
* peek all of the key events on the EventQueue to listen for passwords; if separate EventQueues are
* used for each ThreadGroup using AppContexts, the only key events that applet will be able to
* listen to are its own. A more reasonable applet request would be to change the Swing default
* look-and-feel; with that default stored in an AppContext, the applet's look-and-feel will change
* without disrupting other applets or potentially the browser itself.
*
* <p>Because the AppContext is a facility for safely extending application service support to
* applets, none of its methods may be blocked by a a SecurityManager check in a valid Java
* implementation. Applets may therefore safely invoke any of its methods without worry of being
* blocked.
*
* <p>Note: If a SecurityManager is installed which derives from sun.awt.AWTSecurityManager, it may
* override the AWTSecurityManager.getAppContext() method to return the proper AppContext based on
* the execution context, in the case where the default ThreadGroup-based AppContext indexing would
* return the main "system" AppContext. For example, in an applet situation, if a system thread
* calls into an applet, rather than returning the main "system" AppContext (the one corresponding
* to the system thread), an installed AWTSecurityManager may return the applet's AppContext based
* on the execution context.
*
* @author Thomas Ball
* @author Fred Ecks
*/
public final class AppContext extends AppContextDC {
private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.AppContext");
/* Since the contents of an AppContext are unique to each Java
* session, this class should never be serialized. */
/*
* The key to put()/get() the Java EventQueue into/from the AppContext.
*/
public static final Object EVENT_QUEUE_KEY = new StringBuffer("EventQueue");
/*
* The keys to store EventQueue push/pop lock and condition.
*/
public static final Object EVENT_QUEUE_LOCK_KEY = new StringBuilder("EventQueue.Lock");
public static final Object EVENT_QUEUE_COND_KEY = new StringBuilder("EventQueue.Condition");
/* A map of AppContexts, referenced by ThreadGroup.
*/
private static final Map<ThreadGroup, AppContext> threadGroup2appContext =
Collections.synchronizedMap(new IdentityHashMap<ThreadGroup, AppContext>());
/** Returns a set containing all <code>AppContext</code>s. */
public static Set<AppContext> getAppContexts() {
synchronized (threadGroup2appContext) {
return new HashSet<AppContext>(threadGroup2appContext.values());
}
}
/* The main "system" AppContext, used by everything not otherwise
contained in another AppContext.
*/
private static volatile AppContext mainAppContext = null;
/*
* The hash map associated with this AppContext. A private delegate
* is used instead of subclassing HashMap so as to avoid all of
* HashMap's potentially risky methods, such as clear(), elements(),
* putAll(), etc.
*/
private final HashMap table = new HashMap();
private final ThreadGroup threadGroup;
/**
* If any <code>PropertyChangeListeners</code> have been registered, the <code>changeSupport
* </code> field describes them.
*
* @see #addPropertyChangeListener
* @see #removePropertyChangeListener
* @see #firePropertyChange
*/
private PropertyChangeSupport changeSupport = null;
public static final String DISPOSED_PROPERTY_NAME = "disposed";
public static final String GUI_DISPOSED = "guidisposed";
private volatile boolean isDisposed = false; // true if AppContext is disposed
public boolean isDisposed() {
return isDisposed;
}
static {
// On the main Thread, we get the ThreadGroup, make a corresponding
// AppContext, and instantiate the Java EventQueue. This way, legacy
// code is unaffected by the move to multiple AppContext ability.
AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
ThreadGroup currentThreadGroup = Thread.currentThread().getThreadGroup();
ThreadGroup parentThreadGroup = currentThreadGroup.getParent();
while (parentThreadGroup != null) {
// Find the root ThreadGroup to construct our main AppContext
currentThreadGroup = parentThreadGroup;
parentThreadGroup = currentThreadGroup.getParent();
}
mainAppContext = new AppContext(currentThreadGroup);
numAppContexts = 1;
return mainAppContext;
}
});
}
/*
* The total number of AppContexts, system-wide. This number is
* incremented at the beginning of the constructor, and decremented
* at the end of dispose(). getAppContext() checks to see if this
* number is 1. If so, it returns the sole AppContext without
* checking Thread.currentThread().
*/
private static volatile int numAppContexts;
/*
* The context ClassLoader that was used to create this AppContext.
*/
private final ClassLoader contextClassLoader;
/**
* Constructor for AppContext. This method is <i>not</i> public, nor should it ever be used as
* such. The proper way to construct an AppContext is through the use of
* SunToolkit.createNewAppContext. A ThreadGroup is created for the new AppContext, a Thread is
* created within that ThreadGroup, and that Thread calls SunToolkit.createNewAppContext before
* calling anything else. That creates both the new AppContext and its EventQueue.
*
* @param threadGroup The ThreadGroup for the new AppContext
* @see sun.awt.SunToolkit
* @since 1.2
*/
AppContext(ThreadGroup threadGroup) {
numAppContexts++;
this.threadGroup = threadGroup;
threadGroup2appContext.put(threadGroup, this);
this.contextClassLoader =
AccessController.doPrivileged(
new PrivilegedAction<ClassLoader>() {
public ClassLoader run() {
return Thread.currentThread().getContextClassLoader();
}
});
// Initialize push/pop lock and its condition to be used by all the
// EventQueues within this AppContext
Lock eventQueuePushPopLock = new ReentrantLock();
put(EVENT_QUEUE_LOCK_KEY, eventQueuePushPopLock);
Condition eventQueuePushPopCond = eventQueuePushPopLock.newCondition();
put(EVENT_QUEUE_COND_KEY, eventQueuePushPopCond);
}
private static final ThreadLocal<AppContext> threadAppContext = new ThreadLocal<AppContext>();
/**
* Returns the appropriate AppContext for the caller, as determined by its ThreadGroup. If the
* main "system" AppContext would be returned and there's an AWTSecurityManager installed, it is
* called to get the proper AppContext based on the execution context.
*
* @return the AppContext for the caller.
* @see java.lang.ThreadGroup
* @since 1.2
*/
public static final AppContext getAppContext() {
if (numAppContexts == 1) // If there's only one system-wide,
return mainAppContext; // return the main system AppContext.
AppContext appContext = threadAppContext.get();
if (null == appContext) {
appContext =
AccessController.doPrivileged(
new PrivilegedAction<AppContext>() {
public AppContext run() {
// Get the current ThreadGroup, and look for it and its
// parents in the hash from ThreadGroup to AppContext --
// it should be found, because we use createNewContext()
// when new AppContext objects are created.
ThreadGroup currentThreadGroup = Thread.currentThread().getThreadGroup();
ThreadGroup threadGroup = currentThreadGroup;
AppContext context = threadGroup2appContext.get(threadGroup);
while (context == null) {
threadGroup = threadGroup.getParent();
if (threadGroup == null) {
// If we get here, we're running under a ThreadGroup that
// has no AppContext associated with it. This should never
// happen, because createNewContext() should be used by the
// toolkit to create the ThreadGroup that everything runs
// under.
throw new RuntimeException("Invalid ThreadGroup");
}
context = threadGroup2appContext.get(threadGroup);
}
// In case we did anything in the above while loop, we add
// all the intermediate ThreadGroups to threadGroup2appContext
// so we won't spin again.
for (ThreadGroup tg = currentThreadGroup;
tg != threadGroup;
tg = tg.getParent()) {
threadGroup2appContext.put(tg, context);
}
// Now we're done, so we cache the latest key/value pair.
// (we do this before checking with any AWTSecurityManager, so if
// this Thread equates with the main AppContext in the cache, it
// still will)
threadAppContext.set(context);
return context;
}
});
}
if (appContext == mainAppContext) {
// Before we return the main "system" AppContext, check to
// see if there's an AWTSecurityManager installed. If so,
// allow it to choose the AppContext to return.
SecurityManager securityManager = System.getSecurityManager();
if ((securityManager != null) && (securityManager instanceof AWTSecurityManager)) {
AWTSecurityManager awtSecMgr = (AWTSecurityManager) securityManager;
AppContext secAppContext = awtSecMgr.getAppContext();
if (secAppContext != null) {
appContext = secAppContext; // Return what we're told
}
}
}
return appContext;
}
/**
* Returns the main ("system") AppContext.
*
* @return the main AppContext
* @since 1.8
*/
static final AppContext getMainAppContext() {
return mainAppContext;
}
private long DISPOSAL_TIMEOUT = 5000; // Default to 5-second timeout
// for disposal of all Frames
// (we wait for this time twice,
// once for dispose(), and once
// to clear the EventQueue).
private long THREAD_INTERRUPT_TIMEOUT = 1000;
// Default to 1-second timeout for all
// interrupted Threads to exit, and another
// 1 second for all stopped Threads to die.
/**
* Disposes of this AppContext, all of its top-level Frames, and all Threads and ThreadGroups
* contained within it.
*
* <p>This method must be called from a Thread which is not contained within this AppContext.
*
* @exception IllegalThreadStateException if the current thread is contained within this
* AppContext
* @since 1.2
*/
public void dispose() throws IllegalThreadStateException {
// Check to be sure that the current Thread isn't in this AppContext
if (this.threadGroup.parentOf(Thread.currentThread().getThreadGroup())) {
throw new IllegalThreadStateException(
"Current Thread is contained within AppContext to be disposed.");
}
synchronized (this) {
if (this.isDisposed) {
return; // If already disposed, bail.
}
this.isDisposed = true;
}
final PropertyChangeSupport changeSupport = this.changeSupport;
if (changeSupport != null) {
changeSupport.firePropertyChange(DISPOSED_PROPERTY_NAME, false, true);
}
// First, we post an InvocationEvent to be run on the
// EventDispatchThread which disposes of all top-level Frames and TrayIcons
final Object notificationLock = new Object();
Runnable runnable =
new Runnable() {
public void run() {
// Alert PropertyChangeListeners that the GUI has been disposed.
if (changeSupport != null) {
changeSupport.firePropertyChange(GUI_DISPOSED, false, true);
}
synchronized (notificationLock) {
notificationLock.notifyAll(); // Notify caller that we're done
}
}
};
synchronized (notificationLock) {
SunToolkit.postEvent(this, new InvocationEvent(Toolkit.getDefaultToolkit(), runnable));
try {
notificationLock.wait(DISPOSAL_TIMEOUT);
} catch (InterruptedException e) {
}
}
// Next, we post another InvocationEvent to the end of the
// EventQueue. When it's executed, we know we've executed all
// events in the queue.
runnable =
new Runnable() {
public void run() {
synchronized (notificationLock) {
notificationLock.notifyAll(); // Notify caller that we're done
}
}
};
synchronized (notificationLock) {
SunToolkit.postEvent(this, new InvocationEvent(Toolkit.getDefaultToolkit(), runnable));
try {
notificationLock.wait(DISPOSAL_TIMEOUT);
} catch (InterruptedException e) {
}
}
// Next, we interrupt all Threads in the ThreadGroup
this.threadGroup.interrupt();
// Note, the EventDispatchThread we've interrupted may dump an
// InterruptedException to the console here. This needs to be
// fixed in the EventDispatchThread, not here.
// Next, we sleep 10ms at a time, waiting for all of the active
// Threads in the ThreadGroup to exit.
long startTime = System.currentTimeMillis();
long endTime = startTime + THREAD_INTERRUPT_TIMEOUT;
while ((this.threadGroup.activeCount() > 0) && (System.currentTimeMillis() < endTime)) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
}
}
// Then, we stop any remaining Threads
this.threadGroup.stop();
// Next, we sleep 10ms at a time, waiting for all of the active
// Threads in the ThreadGroup to die.
startTime = System.currentTimeMillis();
endTime = startTime + THREAD_INTERRUPT_TIMEOUT;
while ((this.threadGroup.activeCount() > 0) && (System.currentTimeMillis() < endTime)) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
}
}
// Next, we remove this and all subThreadGroups from threadGroup2appContext
int numSubGroups = this.threadGroup.activeGroupCount();
if (numSubGroups > 0) {
ThreadGroup[] subGroups = new ThreadGroup[numSubGroups];
numSubGroups = this.threadGroup.enumerate(subGroups);
for (int subGroup = 0; subGroup < numSubGroups; subGroup++) {
threadGroup2appContext.remove(subGroups[subGroup]);
}
}
threadGroup2appContext.remove(this.threadGroup);
threadAppContext.set(null);
// Finally, we destroy the ThreadGroup entirely.
try {
this.threadGroup.destroy();
} catch (IllegalThreadStateException e) {
// Fired if not all the Threads died, ignore it and proceed
}
synchronized (table) {
this.table.clear(); // Clear out the Hashtable to ease garbage collection
}
numAppContexts--;
mostRecentKeyValue = null;
}
static final class PostShutdownEventRunnable implements Runnable {
private final AppContext appContext;
public PostShutdownEventRunnable(AppContext ac) {
appContext = ac;
}
public void run() {
final EventQueue eq = (EventQueue) appContext.get(EVENT_QUEUE_KEY);
if (eq != null) {
eq.postEvent(AWTAutoShutdown.getShutdownEvent());
}
}
}
static final class CreateThreadAction implements PrivilegedAction {
private final AppContext appContext;
private final Runnable runnable;
public CreateThreadAction(AppContext ac, Runnable r) {
appContext = ac;
runnable = r;
}
public Object run() {
Thread t = new Thread(appContext.getThreadGroup(), runnable);
t.setContextClassLoader(appContext.getContextClassLoader());
t.setPriority(Thread.NORM_PRIORITY + 1);
t.setDaemon(true);
return t;
}
}
static void stopEventDispatchThreads() {
for (AppContext appContext : getAppContexts()) {
if (appContext.isDisposed()) {
continue;
}
Runnable r = new PostShutdownEventRunnable(appContext);
// For security reasons EventQueue.postEvent should only be called
// on a thread that belongs to the corresponding thread group.
if (appContext != AppContext.getAppContext()) {
// Create a thread that belongs to the thread group associated
// with the AppContext and invokes EventQueue.postEvent.
PrivilegedAction action = new CreateThreadAction(appContext, r);
Thread thread = (Thread) AccessController.doPrivileged(action);
thread.start();
} else {
r.run();
}
}
}
private MostRecentKeyValue mostRecentKeyValue = null;
private MostRecentKeyValue shadowMostRecentKeyValue = null;
/**
* Returns the value to which the specified key is mapped in this context.
*
* @param key a key in the AppContext.
* @return the value to which the key is mapped in this AppContext; <code>null</code> if the key
* is not mapped to any value.
* @see #put(Object, Object)
* @since 1.2
*/
public Object get(Object key) {
/*
* The most recent reference should be updated inside a synchronized
* block to avoid a race when put() and get() are executed in
* parallel on different threads.
*/
synchronized (table) {
// Note: this most recent key/value caching is thread-hot.
// A simple test using SwingSet found that 72% of lookups
// were matched using the most recent key/value. By instantiating
// a simple MostRecentKeyValue object on cache misses, the
// cache hits can be processed without synchronization.
MostRecentKeyValue recent = mostRecentKeyValue;
if ((recent != null) && (recent.key == key)) {
return recent.value;
}
Object value = table.get(key);
if (mostRecentKeyValue == null) {
mostRecentKeyValue = new MostRecentKeyValue(key, value);
shadowMostRecentKeyValue = new MostRecentKeyValue(key, value);
} else {
MostRecentKeyValue auxKeyValue = mostRecentKeyValue;
shadowMostRecentKeyValue.setPair(key, value);
mostRecentKeyValue = shadowMostRecentKeyValue;
shadowMostRecentKeyValue = auxKeyValue;
}
return value;
}
}
/**
* Maps the specified <code>key</code> to the specified <code>value</code> in this AppContext.
* Neither the key nor the value can be <code>null</code>.
*
* <p>The value can be retrieved by calling the <code>get</code> method with a key that is equal
* to the original key.
*
* @param key the AppContext key.
* @param value the value.
* @return the previous value of the specified key in this AppContext, or <code>null</code> if it
* did not have one.
* @exception NullPointerException if the key or value is <code>null</code>.
* @see #get(Object)
* @since 1.2
*/
public Object put(Object key, Object value) {
synchronized (table) {
MostRecentKeyValue recent = mostRecentKeyValue;
if ((recent != null) && (recent.key == key)) recent.value = value;
return table.put(key, value);
}
}
/**
* Removes the key (and its corresponding value) from this AppContext. This method does nothing if
* the key is not in the AppContext.
*
* @param key the key that needs to be removed.
* @return the value to which the key had been mapped in this AppContext, or <code>null</code> if
* the key did not have a mapping.
* @since 1.2
*/
public Object remove(Object key) {
synchronized (table) {
MostRecentKeyValue recent = mostRecentKeyValue;
if ((recent != null) && (recent.key == key)) recent.value = null;
return table.remove(key);
}
}
/**
* Returns the root ThreadGroup for all Threads contained within this AppContext.
*
* @since 1.2
*/
public ThreadGroup getThreadGroup() {
return threadGroup;
}
/**
* Returns the context ClassLoader that was used to create this AppContext.
*
* @see java.lang.Thread#getContextClassLoader
*/
public ClassLoader getContextClassLoader() {
return contextClassLoader;
}
/**
* Returns a string representation of this AppContext.
*
* @since 1.2
*/
@Override
public String toString() {
return getClass().getName() + "[threadGroup=" + threadGroup.getName() + "]";
}
/**
* Returns an array of all the property change listeners registered on this component.
*
* @return all of this component's <code>PropertyChangeListener</code>s or an empty array if no
* property change listeners are currently registered
* @see #addPropertyChangeListener
* @see #removePropertyChangeListener
* @see #getPropertyChangeListeners(java.lang.String)
* @see java.beans.PropertyChangeSupport#getPropertyChangeListeners
* @since 1.4
*/
public synchronized PropertyChangeListener[] getPropertyChangeListeners() {
if (changeSupport == null) {
return new PropertyChangeListener[0];
}
return changeSupport.getPropertyChangeListeners();
}
/**
* Adds a PropertyChangeListener to the listener list for a specific property. The specified
* property may be one of the following:
*
* <ul>
* <li>if this AppContext is disposed ("disposed")
* </ul>
*
* <ul>
* <li>if this AppContext's unowned Windows have been disposed ("guidisposed"). Code to cleanup
* after the GUI is disposed (such as LookAndFeel.uninitialize()) should execute in response
* to this property being fired. Notifications for the "guidisposed" property are sent on
* the event dispatch thread.
* </ul>
*
* <p>If listener is null, no exception is thrown and no action is performed.
*
* @param propertyName one of the property names listed above
* @param listener the PropertyChangeListener to be added
* @see #removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
* @see #getPropertyChangeListeners(java.lang.String)
* @see #addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
*/
public synchronized void addPropertyChangeListener(
String propertyName, PropertyChangeListener listener) {
if (listener == null) {
return;
}
if (changeSupport == null) {
changeSupport = new PropertyChangeSupport(this);
}
changeSupport.addPropertyChangeListener(propertyName, listener);
}
/**
* Removes a PropertyChangeListener from the listener list for a specific property. This method
* should be used to remove PropertyChangeListeners that were registered for a specific bound
* property.
*
* <p>If listener is null, no exception is thrown and no action is performed.
*
* @param propertyName a valid property name
* @param listener the PropertyChangeListener to be removed
* @see #addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
* @see #getPropertyChangeListeners(java.lang.String)
* @see #removePropertyChangeListener(java.beans.PropertyChangeListener)
*/
public synchronized void removePropertyChangeListener(
String propertyName, PropertyChangeListener listener) {
if (listener == null || changeSupport == null) {
return;
}
changeSupport.removePropertyChangeListener(propertyName, listener);
}
/**
* Returns an array of all the listeners which have been associated with the named property.
*
* @return all of the <code>PropertyChangeListeners</code> associated with the named property or
* an empty array if no listeners have been added
* @see #addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
* @see #removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
* @see #getPropertyChangeListeners
* @since 1.4
*/
public synchronized PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
if (changeSupport == null) {
return new PropertyChangeListener[0];
}
return changeSupport.getPropertyChangeListeners(propertyName);
}
}
/**
* This class implements window which serves as content window for decorated frames. Its purpose to
* provide correct events dispatching for the complex constructs such as decorated frames.
*
* <p>It should always be located at (- left inset, - top inset) in the associated decorated window.
* So coordinates in it would be the same as java coordinates.
*/
public final class XContentWindow extends XWindow {
private static PlatformLogger insLog =
PlatformLogger.getLogger("sun.awt.X11.insets.XContentWindow");
static XContentWindow createContent(XDecoratedPeer parentFrame) {
final WindowDimensions dims = parentFrame.getDimensions();
Rectangle rec = dims.getBounds();
// Fix for - set the location of the content window to the (-left inset, -top inset)
Insets ins = dims.getInsets();
if (ins != null) {
rec.x = -ins.left;
rec.y = -ins.top;
} else {
rec.x = 0;
rec.y = 0;
}
final XContentWindow cw = new XContentWindow(parentFrame, rec);
cw.xSetVisible(true);
return cw;
}
private final XDecoratedPeer parentFrame;
// A list of expose events that come when the parentFrame is iconified
private final java.util.List<SavedExposeEvent> iconifiedExposeEvents =
new java.util.ArrayList<SavedExposeEvent>();
private XContentWindow(XDecoratedPeer parentFrame, Rectangle bounds) {
super((Component) parentFrame.getTarget(), parentFrame.getShell(), bounds);
this.parentFrame = parentFrame;
}
void preInit(XCreateWindowParams params) {
super.preInit(params);
params.putIfNull(BIT_GRAVITY, Integer.valueOf(XConstants.NorthWestGravity));
Long eventMask = (Long) params.get(EVENT_MASK);
if (eventMask != null) {
eventMask = eventMask & ~(XConstants.StructureNotifyMask);
params.put(EVENT_MASK, eventMask);
}
}
protected String getWMName() {
return "Content window";
}
protected boolean isEventDisabled(XEvent e) {
switch (e.get_type()) {
// Override parentFrame to receive MouseEnter/Exit
case XConstants.EnterNotify:
case XConstants.LeaveNotify:
return false;
// We handle ConfigureNotify specifically in XDecoratedPeer
case XConstants.ConfigureNotify:
return true;
// We don't want SHOWN/HIDDEN on content window since it will duplicate XDecoratedPeer
case XConstants.MapNotify:
case XConstants.UnmapNotify:
return true;
default:
return super.isEventDisabled(e) || parentFrame.isEventDisabled(e);
}
}
// Coordinates are that of the shell
void setContentBounds(WindowDimensions dims) {
XToolkit.awtLock();
try {
// Bounds of content window are of the same size as bounds of Java window and with
// location as -(insets)
Rectangle newBounds = dims.getBounds();
Insets in = dims.getInsets();
if (in != null) {
newBounds.setLocation(-in.left, -in.top);
}
if (insLog.isLoggable(PlatformLogger.Level.FINE)) {
insLog.fine("Setting content bounds {0}, old bounds {1}", newBounds, getBounds());
}
// Fix for 5023533:
// Change in the size of the content window means, well, change of the size
// Change in the location of the content window means change in insets
boolean needHandleResize = !(newBounds.equals(getBounds()));
reshape(newBounds);
if (needHandleResize) {
insLog.fine("Sending RESIZED");
handleResize(newBounds);
}
} finally {
XToolkit.awtUnlock();
}
validateSurface();
}
// NOTE: This method may be called by privileged threads.
// DO NOT INVOKE CLIENT CODE ON THIS THREAD!
public void handleResize(Rectangle bounds) {
AWTAccessor.getComponentAccessor().setSize((Component) target, bounds.width, bounds.height);
postEvent(new ComponentEvent(target, ComponentEvent.COMPONENT_RESIZED));
}
public void handleExposeEvent(Component target, int x, int y, int w, int h) {
// TODO: ?
// get rid of 'istanceof' by subclassing:
// XContentWindow -> XFrameContentWindow
// Expose event(s) that result from deiconification
// come before a deicinofication notification.
// We reorder these events by saving all expose events
// that come when the frame is iconified. Then we
// actually handle saved expose events on deiconification.
if (parentFrame instanceof XFramePeer
&& (((XFramePeer) parentFrame).getState() & java.awt.Frame.ICONIFIED) != 0) {
// Save expose events if the frame is iconified
// in order to handle them on deiconification.
iconifiedExposeEvents.add(new SavedExposeEvent(target, x, y, w, h));
} else {
// Normal case: [it is not a frame or] the frame is not iconified.
super.handleExposeEvent(target, x, y, w, h);
}
}
void purgeIconifiedExposeEvents() {
for (SavedExposeEvent evt : iconifiedExposeEvents) {
super.handleExposeEvent(evt.target, evt.x, evt.y, evt.w, evt.h);
}
iconifiedExposeEvents.clear();
}
private static class SavedExposeEvent {
Component target;
int x, y, w, h;
SavedExposeEvent(Component target, int x, int y, int w, int h) {
this.target = target;
this.x = x;
this.y = y;
this.w = w;
this.h = h;
}
}
public String toString() {
return getClass().getName() + "[" + getBounds() + "]";
}
}
public class LWWindowPeer extends LWContainerPeer<Window, JComponent>
implements FramePeer,
DialogPeer,
FullScreenCapable,
DisplayChangedListener,
PlatformEventNotifier {
public enum PeerType {
SIMPLEWINDOW,
FRAME,
DIALOG,
EMBEDDED_FRAME,
VIEW_EMBEDDED_FRAME,
LW_FRAME
}
private static final PlatformLogger focusLog =
PlatformLogger.getLogger("sun.lwawt.focus.LWWindowPeer");
private final PlatformWindow platformWindow;
private static final int MINIMUM_WIDTH = 1;
private static final int MINIMUM_HEIGHT = 1;
private Insets insets = new Insets(0, 0, 0, 0);
private GraphicsDevice graphicsDevice;
private GraphicsConfiguration graphicsConfig;
private SurfaceData surfaceData;
private final Object surfaceDataLock = new Object();
private volatile int windowState = Frame.NORMAL;
// check that the mouse is over the window
private volatile boolean isMouseOver = false;
// A peer where the last mouse event came to. Used by cursor manager to
// find the component under cursor
private static volatile LWComponentPeer<?, ?> lastCommonMouseEventPeer;
// A peer where the last mouse event came to. Used to generate
// MOUSE_ENTERED/EXITED notifications
private volatile LWComponentPeer<?, ?> lastMouseEventPeer;
// Peers where all dragged/released events should come to,
// depending on what mouse button is being dragged according to Cocoa
private static final LWComponentPeer<?, ?>[] mouseDownTarget = new LWComponentPeer<?, ?>[3];
// A bitmask that indicates what mouse buttons produce MOUSE_CLICKED events
// on MOUSE_RELEASE. Click events are only generated if there were no drag
// events between MOUSE_PRESSED and MOUSE_RELEASED for particular button
private static int mouseClickButtons = 0;
private volatile boolean isOpaque = true;
private static final Font DEFAULT_FONT = new Font("Lucida Grande", Font.PLAIN, 13);
private static LWWindowPeer grabbingWindow;
private volatile boolean skipNextFocusChange;
private static final Color nonOpaqueBackground = new Color(0, 0, 0, 0);
private volatile boolean textured;
private final PeerType peerType;
private final SecurityWarningWindow warningWindow;
private volatile boolean targetFocusable;
/**
* Current modal blocker or null.
*
* <p>Synchronization: peerTreeLock.
*/
private LWWindowPeer blocker;
public LWWindowPeer(
Window target,
PlatformComponent platformComponent,
PlatformWindow platformWindow,
PeerType peerType) {
super(target, platformComponent);
this.platformWindow = platformWindow;
this.peerType = peerType;
Window owner = target.getOwner();
LWWindowPeer ownerPeer =
owner == null ? null : (LWWindowPeer) AWTAccessor.getComponentAccessor().getPeer(owner);
PlatformWindow ownerDelegate = (ownerPeer != null) ? ownerPeer.getPlatformWindow() : null;
// The delegate.initialize() needs a non-null GC on X11.
GraphicsConfiguration gc = getTarget().getGraphicsConfiguration();
synchronized (getStateLock()) {
// graphicsConfig should be updated according to the real window
// bounds when the window is shown, see 4868278
this.graphicsConfig = gc;
}
if (!target.isFontSet()) {
target.setFont(DEFAULT_FONT);
}
if (!target.isBackgroundSet()) {
target.setBackground(SystemColor.window);
} else {
// first we check if user provided alpha for background. This is
// similar to what Apple's Java do.
// Since JDK7 we should rely on setOpacity() only.
// this.opacity = c.getAlpha();
}
if (!target.isForegroundSet()) {
target.setForeground(SystemColor.windowText);
// we should not call setForeground because it will call a repaint
// which the peer may not be ready to do yet.
}
platformWindow.initialize(target, this, ownerDelegate);
// Init warning window(for applets)
SecurityWarningWindow warn = null;
if (target.getWarningString() != null) {
// accessSystemTray permission allows to display TrayIcon, TrayIcon tooltip
// and TrayIcon balloon windows without a warning window.
if (!AWTAccessor.getWindowAccessor().isTrayIconWindow(target)) {
LWToolkit toolkit = (LWToolkit) Toolkit.getDefaultToolkit();
warn = toolkit.createSecurityWarning(target, this);
}
}
warningWindow = warn;
}
@Override
void initializeImpl() {
super.initializeImpl();
if (getTarget() instanceof Frame) {
setTitle(((Frame) getTarget()).getTitle());
setState(((Frame) getTarget()).getExtendedState());
} else if (getTarget() instanceof Dialog) {
setTitle(((Dialog) getTarget()).getTitle());
}
updateAlwaysOnTopState();
updateMinimumSize();
updateFocusableWindowState();
final Shape shape = getTarget().getShape();
if (shape != null) {
applyShape(Region.getInstance(shape, null));
}
final float opacity = getTarget().getOpacity();
if (opacity < 1.0f) {
setOpacity(opacity);
}
setOpaque(getTarget().isOpaque());
updateInsets(platformWindow.getInsets());
if (getSurfaceData() == null) {
replaceSurfaceData(false);
}
activateDisplayListener();
}
// Just a helper method
@Override
public PlatformWindow getPlatformWindow() {
return platformWindow;
}
@Override
protected LWWindowPeer getWindowPeerOrSelf() {
return this;
}
// ---- PEER METHODS ---- //
@Override
protected void disposeImpl() {
deactivateDisplayListener();
SurfaceData oldData = getSurfaceData();
synchronized (surfaceDataLock) {
surfaceData = null;
}
if (oldData != null) {
oldData.invalidate();
}
if (isGrabbing()) {
ungrab();
}
if (warningWindow != null) {
warningWindow.dispose();
}
platformWindow.dispose();
super.disposeImpl();
}
@Override
protected void setVisibleImpl(final boolean visible) {
if (!visible && warningWindow != null) {
warningWindow.setVisible(false, false);
}
updateFocusableWindowState();
super.setVisibleImpl(visible);
// TODO: update graphicsConfig, see 4868278
platformWindow.setVisible(visible);
if (isSimpleWindow()) {
KeyboardFocusManagerPeer kfmPeer = LWKeyboardFocusManagerPeer.getInstance();
if (visible) {
if (!getTarget().isAutoRequestFocus()) {
return;
} else {
requestWindowFocus(CausedFocusEvent.Cause.ACTIVATION);
}
// Focus the owner in case this window is focused.
} else if (kfmPeer.getCurrentFocusedWindow() == getTarget()) {
// Transfer focus to the owner.
LWWindowPeer owner = getOwnerFrameDialog(LWWindowPeer.this);
if (owner != null) {
owner.requestWindowFocus(CausedFocusEvent.Cause.ACTIVATION);
}
}
}
}
@Override
public final GraphicsConfiguration getGraphicsConfiguration() {
synchronized (getStateLock()) {
return graphicsConfig;
}
}
@Override
public boolean updateGraphicsData(GraphicsConfiguration gc) {
setGraphicsConfig(gc);
return false;
}
protected final Graphics getOnscreenGraphics(Color fg, Color bg, Font f) {
if (getSurfaceData() == null) {
return null;
}
if (fg == null) {
fg = SystemColor.windowText;
}
if (bg == null) {
bg = SystemColor.window;
}
if (f == null) {
f = DEFAULT_FONT;
}
return platformWindow.transformGraphics(new SunGraphics2D(getSurfaceData(), fg, bg, f));
}
@Override
public void setBounds(int x, int y, int w, int h, int op) {
if ((op & NO_EMBEDDED_CHECK) == 0 && getPeerType() == PeerType.VIEW_EMBEDDED_FRAME) {
return;
}
if ((op & SET_CLIENT_SIZE) != 0) {
// SET_CLIENT_SIZE is only applicable to window peers, so handle it here
// instead of pulling 'insets' field up to LWComponentPeer
// no need to add insets since Window's notion of width and height includes insets.
op &= ~SET_CLIENT_SIZE;
op |= SET_SIZE;
}
// Don't post ComponentMoved/Resized and Paint events
// until we've got a notification from the delegate
Rectangle cb = constrainBounds(x, y, w, h);
Rectangle newBounds = new Rectangle(getBounds());
if ((op & (SET_LOCATION | SET_BOUNDS)) != 0) {
newBounds.x = cb.x;
newBounds.y = cb.y;
}
if ((op & (SET_SIZE | SET_BOUNDS)) != 0) {
newBounds.width = cb.width;
newBounds.height = cb.height;
}
// Native system could constraint bounds, so the peer wold be updated in the callback
platformWindow.setBounds(newBounds.x, newBounds.y, newBounds.width, newBounds.height);
}
public Rectangle constrainBounds(Rectangle bounds) {
return constrainBounds(bounds.x, bounds.y, bounds.width, bounds.height);
}
public Rectangle constrainBounds(int x, int y, int w, int h) {
if (w < MINIMUM_WIDTH) {
w = MINIMUM_WIDTH;
}
if (h < MINIMUM_HEIGHT) {
h = MINIMUM_HEIGHT;
}
final int maxW = getLWGC().getMaxTextureWidth();
final int maxH = getLWGC().getMaxTextureHeight();
if (w > maxW) {
w = maxW;
}
if (h > maxH) {
h = maxH;
}
return new Rectangle(x, y, w, h);
}
@Override
public Point getLocationOnScreen() {
return platformWindow.getLocationOnScreen();
}
/**
* Overridden from LWContainerPeer to return the correct insets. Insets are queried from the
* delegate and are kept up to date by requiering when needed (i.e. when the window geometry is
* changed).
*/
@Override
public Insets getInsets() {
synchronized (getStateLock()) {
return insets;
}
}
@Override
public FontMetrics getFontMetrics(Font f) {
// TODO: check for "use platform metrics" settings
return platformWindow.getFontMetrics(f);
}
@Override
public void toFront() {
platformWindow.toFront();
}
@Override
public void toBack() {
platformWindow.toBack();
}
@Override
public void setZOrder(ComponentPeer above) {
throw new RuntimeException("not implemented");
}
@Override
public void updateAlwaysOnTopState() {
platformWindow.setAlwaysOnTop(getTarget().isAlwaysOnTop());
}
@Override
public void updateFocusableWindowState() {
targetFocusable = getTarget().isFocusableWindow();
platformWindow.updateFocusableWindowState();
}
@Override
public void setModalBlocked(Dialog blocker, boolean blocked) {
synchronized (getPeerTreeLock()) {
ComponentPeer peer = AWTAccessor.getComponentAccessor().getPeer(blocker);
if (blocked && (peer instanceof LWWindowPeer)) {
this.blocker = (LWWindowPeer) peer;
} else {
this.blocker = null;
}
}
platformWindow.setModalBlocked(blocked);
}
@Override
public void updateMinimumSize() {
final Dimension min;
if (getTarget().isMinimumSizeSet()) {
min = getTarget().getMinimumSize();
min.width = Math.max(min.width, MINIMUM_WIDTH);
min.height = Math.max(min.height, MINIMUM_HEIGHT);
} else {
min = new Dimension(MINIMUM_WIDTH, MINIMUM_HEIGHT);
}
final Dimension max;
if (getTarget().isMaximumSizeSet()) {
max = getTarget().getMaximumSize();
max.width = Math.min(max.width, getLWGC().getMaxTextureWidth());
max.height = Math.min(max.height, getLWGC().getMaxTextureHeight());
} else {
max = new Dimension(getLWGC().getMaxTextureWidth(), getLWGC().getMaxTextureHeight());
}
platformWindow.setSizeConstraints(min.width, min.height, max.width, max.height);
}
@Override
public void updateIconImages() {
getPlatformWindow().updateIconImages();
}
@Override
public void setBackground(final Color c) {
super.setBackground(c);
updateOpaque();
}
@Override
public void setOpacity(float opacity) {
getPlatformWindow().setOpacity(opacity);
repaintPeer();
}
@Override
public final void setOpaque(final boolean isOpaque) {
if (this.isOpaque != isOpaque) {
this.isOpaque = isOpaque;
updateOpaque();
}
}
private void updateOpaque() {
getPlatformWindow().setOpaque(!isTranslucent());
replaceSurfaceData(false);
repaintPeer();
}
@Override
public void updateWindow() {}
public final boolean isTextured() {
return textured;
}
public final void setTextured(final boolean isTextured) {
textured = isTextured;
}
@Override
public final boolean isTranslucent() {
synchronized (getStateLock()) {
/*
* Textured window is a special case of translucent window.
* The difference is only in nswindow background. So when we set
* texture property our peer became fully translucent. It doesn't
* fill background, create non opaque backbuffers and layer etc.
*/
return !isOpaque || isShaped() || isTextured();
}
}
@Override
final void applyShapeImpl(final Region shape) {
super.applyShapeImpl(shape);
updateOpaque();
}
@Override
public void repositionSecurityWarning() {
if (warningWindow != null) {
AWTAccessor.ComponentAccessor compAccessor = AWTAccessor.getComponentAccessor();
Window target = getTarget();
int x = compAccessor.getX(target);
int y = compAccessor.getY(target);
int width = compAccessor.getWidth(target);
int height = compAccessor.getHeight(target);
warningWindow.reposition(x, y, width, height);
}
}
// ---- FRAME PEER METHODS ---- //
@Override // FramePeer and DialogPeer
public void setTitle(String title) {
platformWindow.setTitle(title == null ? "" : title);
}
@Override
public void setMenuBar(MenuBar mb) {
platformWindow.setMenuBar(mb);
}
@Override // FramePeer and DialogPeer
public void setResizable(boolean resizable) {
platformWindow.setResizable(resizable);
}
@Override
public void setState(int state) {
platformWindow.setWindowState(state);
}
@Override
public int getState() {
return windowState;
}
@Override
public void setMaximizedBounds(Rectangle bounds) {
// TODO: not implemented
}
@Override
public void setBoundsPrivate(int x, int y, int width, int height) {
setBounds(x, y, width, height, SET_BOUNDS | NO_EMBEDDED_CHECK);
}
@Override
public Rectangle getBoundsPrivate() {
throw new RuntimeException("not implemented");
}
// ---- DIALOG PEER METHODS ---- //
@Override
public void blockWindows(List<Window> windows) {
// TODO: LWX will probably need some collectJavaToplevels to speed this up
for (Window w : windows) {
WindowPeer wp = (WindowPeer) AWTAccessor.getComponentAccessor().getPeer(w);
if (wp != null) {
wp.setModalBlocked((Dialog) getTarget(), true);
}
}
}
// ---- PEER NOTIFICATIONS ---- //
@Override
public void notifyIconify(boolean iconify) {
// The toplevel target is Frame and states are applicable to it.
// Otherwise, the target is Window and it don't have state property.
// Hopefully, no such events are posted in the queue so consider the
// target as Frame in all cases.
// REMIND: should we send it anyway if the state not changed since last
// time?
WindowEvent iconifyEvent =
new WindowEvent(
getTarget(), iconify ? WindowEvent.WINDOW_ICONIFIED : WindowEvent.WINDOW_DEICONIFIED);
postEvent(iconifyEvent);
int newWindowState = iconify ? Frame.ICONIFIED : Frame.NORMAL;
postWindowStateChangedEvent(newWindowState);
// REMIND: RepaintManager doesn't repaint iconified windows and
// hence ignores any repaint request during deiconification.
// So, we need to repaint window explicitly when it becomes normal.
if (!iconify) {
repaintPeer();
}
}
@Override
public void notifyZoom(boolean isZoomed) {
int newWindowState = isZoomed ? Frame.MAXIMIZED_BOTH : Frame.NORMAL;
postWindowStateChangedEvent(newWindowState);
}
/** Called by the {@code PlatformWindow} when any part of the window should be repainted. */
@Override
public void notifyExpose(final Rectangle r) {
repaintPeer(r);
}
/**
* Called by the {@code PlatformWindow} when this window is moved/resized by user or window insets
* are changed. There's no notifyReshape() in LWComponentPeer as the only components which could
* be resized by user are top-level windows.
*/
@Override
public void notifyReshape(int x, int y, int w, int h) {
Rectangle oldBounds = getBounds();
final boolean invalid = updateInsets(platformWindow.getInsets());
final boolean moved = (x != oldBounds.x) || (y != oldBounds.y);
final boolean resized = (w != oldBounds.width) || (h != oldBounds.height);
// Check if anything changed
if (!moved && !resized && !invalid) {
return;
}
// First, update peer's bounds
setBounds(x, y, w, h, SET_BOUNDS, false, false);
// Second, update the graphics config and surface data
final boolean isNewDevice = updateGraphicsDevice();
if (resized || isNewDevice) {
replaceSurfaceData();
updateMinimumSize();
}
// Third, COMPONENT_MOVED/COMPONENT_RESIZED/PAINT events
if (moved || invalid) {
handleMove(x, y, true);
}
if (resized || invalid || isNewDevice) {
handleResize(w, h, true);
repaintPeer();
}
repositionSecurityWarning();
}
private void clearBackground(final int w, final int h) {
final Graphics g = getOnscreenGraphics(getForeground(), getBackground(), getFont());
if (g != null) {
try {
if (g instanceof Graphics2D) {
((Graphics2D) g).setComposite(AlphaComposite.Src);
}
if (isTranslucent()) {
g.setColor(nonOpaqueBackground);
g.fillRect(0, 0, w, h);
}
if (!isTextured()) {
if (g instanceof SunGraphics2D) {
((SunGraphics2D) g).constrain(0, 0, w, h, getRegion());
}
g.setColor(getBackground());
g.fillRect(0, 0, w, h);
}
} finally {
g.dispose();
}
}
}
@Override
public void notifyUpdateCursor() {
getLWToolkit().getCursorManager().updateCursorLater(this);
}
@Override
public void notifyActivation(boolean activation, LWWindowPeer opposite) {
Window oppositeWindow = (opposite == null) ? null : opposite.getTarget();
changeFocusedWindow(activation, oppositeWindow);
}
// MouseDown in non-client area
@Override
public void notifyNCMouseDown() {
// Ungrab except for a click on a Dialog with the grabbing owner
if (grabbingWindow != null && !grabbingWindow.isOneOfOwnersOf(this)) {
grabbingWindow.ungrab();
}
}
// ---- EVENTS ---- //
/*
* Called by the delegate to dispatch the event to Java. Event
* coordinates are relative to non-client window are, i.e. the top-left
* point of the client area is (insets.top, insets.left).
*/
@Override
public void notifyMouseEvent(
PlatformWindow eventPlatformWindow,
int id,
long when,
int button,
int x,
int y,
int screenX,
int screenY,
int modifiers,
int clickCount,
boolean popupTrigger,
byte[] bdata) {
// TODO: fill "bdata" member of AWTEvent
Rectangle r = getBounds();
// findPeerAt() expects parent coordinates
LWComponentPeer<?, ?> targetPeer = findPeerAt(r.x + x, r.y + y);
if (id == MouseEvent.MOUSE_EXITED) {
isMouseOver = false;
if (lastMouseEventPeer != null) {
if (lastMouseEventPeer.isEnabled()) {
Point lp = lastMouseEventPeer.windowToLocal(x, y, this);
Component target = lastMouseEventPeer.getTarget();
postMouseExitedEvent(
target, when, modifiers, lp, screenX, screenY, clickCount, popupTrigger, button);
}
// Sometimes we may get MOUSE_EXITED after lastCommonMouseEventPeer is switched
// to a peer from another window. So we must first check if this peer is
// the same as lastWindowPeer
if (lastCommonMouseEventPeer != null
&& lastCommonMouseEventPeer.getWindowPeerOrSelf() == this) {
lastCommonMouseEventPeer = null;
}
lastMouseEventPeer = null;
}
} else if (id == MouseEvent.MOUSE_ENTERED) {
isMouseOver = true;
if (targetPeer != null) {
if (targetPeer.isEnabled()) {
Point lp = targetPeer.windowToLocal(x, y, this);
Component target = targetPeer.getTarget();
postMouseEnteredEvent(
target, when, modifiers, lp, screenX, screenY, clickCount, popupTrigger, button);
}
lastCommonMouseEventPeer = targetPeer;
lastMouseEventPeer = targetPeer;
}
} else {
LWWindowPeer topmostWindowPeer =
eventPlatformWindow != null ? eventPlatformWindow.getPeer() : null;
// topmostWindowPeer == null condition is added for the backward
// compatibility with applets. It can be removed when the
// getTopmostPlatformWindowUnderMouse() method will be properly
// implemented in CPlatformEmbeddedFrame class
if (topmostWindowPeer == this || topmostWindowPeer == null) {
generateMouseEnterExitEventsForComponents(
when, button, x, y, screenX, screenY, modifiers, clickCount, popupTrigger, targetPeer);
} else {
LWComponentPeer<?, ?> topmostTargetPeer = topmostWindowPeer.findPeerAt(r.x + x, r.y + y);
topmostWindowPeer.generateMouseEnterExitEventsForComponents(
when,
button,
x,
y,
screenX,
screenY,
modifiers,
clickCount,
popupTrigger,
topmostTargetPeer);
}
// TODO: fill "bdata" member of AWTEvent
int eventButtonMask = (button > 0) ? MouseEvent.getMaskForButton(button) : 0;
int otherButtonsPressed = modifiers & ~eventButtonMask;
// For pressed/dragged/released events OS X treats other
// mouse buttons as if they were BUTTON2, so we do the same
int targetIdx = (button > 3) ? MouseEvent.BUTTON2 - 1 : button - 1;
// MOUSE_ENTERED/EXITED are generated for the components strictly under
// mouse even when dragging. That's why we first update lastMouseEventPeer
// based on initial targetPeer value and only then recalculate targetPeer
// for MOUSE_DRAGGED/RELEASED events
if (id == MouseEvent.MOUSE_PRESSED) {
// Ungrab only if this window is not an owned window of the grabbing one.
if (!isGrabbing() && grabbingWindow != null && !grabbingWindow.isOneOfOwnersOf(this)) {
grabbingWindow.ungrab();
}
if (otherButtonsPressed == 0) {
mouseClickButtons = eventButtonMask;
} else {
mouseClickButtons |= eventButtonMask;
}
// The window should be focused on mouse click. If it gets activated by the native platform,
// this request will be no op. It will take effect when:
// 1. A simple not focused window is clicked.
// 2. An active but not focused owner frame/dialog is clicked.
// The mouse event then will trigger a focus request "in window" to the component, so the
// window
// should gain focus before.
requestWindowFocus(CausedFocusEvent.Cause.MOUSE_EVENT);
mouseDownTarget[targetIdx] = targetPeer;
} else if (id == MouseEvent.MOUSE_DRAGGED) {
// Cocoa dragged event has the information about which mouse
// button is being dragged. Use it to determine the peer that
// should receive the dragged event.
targetPeer = mouseDownTarget[targetIdx];
mouseClickButtons &= ~modifiers;
} else if (id == MouseEvent.MOUSE_RELEASED) {
// TODO: currently, mouse released event goes to the same component
// that received corresponding mouse pressed event. For most cases,
// it's OK, however, we need to make sure that our behavior is consistent
// with 1.6 for cases where component in question have been
// hidden/removed in between of mouse pressed/released events.
targetPeer = mouseDownTarget[targetIdx];
if ((modifiers & eventButtonMask) == 0) {
mouseDownTarget[targetIdx] = null;
}
// mouseClickButtons is updated below, after MOUSE_CLICK is sent
}
if (targetPeer == null) {
// TODO This can happen if this window is invisible. this is correct behavior in this case?
targetPeer = this;
}
Point lp = targetPeer.windowToLocal(x, y, this);
if (targetPeer.isEnabled()) {
MouseEvent event =
new MouseEvent(
targetPeer.getTarget(),
id,
when,
modifiers,
lp.x,
lp.y,
screenX,
screenY,
clickCount,
popupTrigger,
button);
postEvent(event);
}
if (id == MouseEvent.MOUSE_RELEASED) {
if ((mouseClickButtons & eventButtonMask) != 0 && targetPeer.isEnabled()) {
postEvent(
new MouseEvent(
targetPeer.getTarget(),
MouseEvent.MOUSE_CLICKED,
when,
modifiers,
lp.x,
lp.y,
screenX,
screenY,
clickCount,
popupTrigger,
button));
}
mouseClickButtons &= ~eventButtonMask;
}
}
notifyUpdateCursor();
}
private void generateMouseEnterExitEventsForComponents(
long when,
int button,
int x,
int y,
int screenX,
int screenY,
int modifiers,
int clickCount,
boolean popupTrigger,
final LWComponentPeer<?, ?> targetPeer) {
if (!isMouseOver || targetPeer == lastMouseEventPeer) {
return;
}
// Generate Mouse Exit for components
if (lastMouseEventPeer != null && lastMouseEventPeer.isEnabled()) {
Point oldp = lastMouseEventPeer.windowToLocal(x, y, this);
Component target = lastMouseEventPeer.getTarget();
postMouseExitedEvent(
target, when, modifiers, oldp, screenX, screenY, clickCount, popupTrigger, button);
}
lastCommonMouseEventPeer = targetPeer;
lastMouseEventPeer = targetPeer;
// Generate Mouse Enter for components
if (targetPeer != null && targetPeer.isEnabled()) {
Point newp = targetPeer.windowToLocal(x, y, this);
Component target = targetPeer.getTarget();
postMouseEnteredEvent(
target, when, modifiers, newp, screenX, screenY, clickCount, popupTrigger, button);
}
}
private void postMouseEnteredEvent(
Component target,
long when,
int modifiers,
Point loc,
int xAbs,
int yAbs,
int clickCount,
boolean popupTrigger,
int button) {
updateSecurityWarningVisibility();
postEvent(
new MouseEvent(
target,
MouseEvent.MOUSE_ENTERED,
when,
modifiers,
loc.x,
loc.y,
xAbs,
yAbs,
clickCount,
popupTrigger,
button));
}
private void postMouseExitedEvent(
Component target,
long when,
int modifiers,
Point loc,
int xAbs,
int yAbs,
int clickCount,
boolean popupTrigger,
int button) {
updateSecurityWarningVisibility();
postEvent(
new MouseEvent(
target,
MouseEvent.MOUSE_EXITED,
when,
modifiers,
loc.x,
loc.y,
xAbs,
yAbs,
clickCount,
popupTrigger,
button));
}
@Override
public void notifyMouseWheelEvent(
long when,
int x,
int y,
int modifiers,
int scrollType,
int scrollAmount,
int wheelRotation,
double preciseWheelRotation,
byte[] bdata) {
// TODO: could we just use the last mouse event target here?
Rectangle r = getBounds();
// findPeerAt() expects parent coordinates
final LWComponentPeer<?, ?> targetPeer = findPeerAt(r.x + x, r.y + y);
if (targetPeer == null || !targetPeer.isEnabled()) {
return;
}
Point lp = targetPeer.windowToLocal(x, y, this);
// TODO: fill "bdata" member of AWTEvent
// TODO: screenX/screenY
postEvent(
new MouseWheelEvent(
targetPeer.getTarget(),
MouseEvent.MOUSE_WHEEL,
when,
modifiers,
lp.x,
lp.y,
0,
0, /* screenX, Y */
0 /* clickCount */,
false /* popupTrigger */,
scrollType,
scrollAmount,
wheelRotation,
preciseWheelRotation));
}
/*
* Called by the delegate when a key is pressed.
*/
@Override
public void notifyKeyEvent(
int id, long when, int modifiers, int keyCode, char keyChar, int keyLocation) {
LWKeyboardFocusManagerPeer kfmPeer = LWKeyboardFocusManagerPeer.getInstance();
Component focusOwner = kfmPeer.getCurrentFocusOwner();
if (focusOwner == null) {
focusOwner = kfmPeer.getCurrentFocusedWindow();
if (focusOwner == null) {
focusOwner = this.getTarget();
}
}
KeyEvent keyEvent =
new KeyEvent(focusOwner, id, when, modifiers, keyCode, keyChar, keyLocation);
AWTAccessor.getKeyEventAccessor()
.setExtendedKeyCode(
keyEvent,
(keyChar == KeyEvent.CHAR_UNDEFINED)
? keyCode
: ExtendedKeyCodes.getExtendedKeyCodeForChar(keyChar));
postEvent(keyEvent);
}
// ---- UTILITY METHODS ---- //
private void activateDisplayListener() {
final GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
((SunGraphicsEnvironment) ge).addDisplayChangedListener(this);
}
private void deactivateDisplayListener() {
final GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
((SunGraphicsEnvironment) ge).removeDisplayChangedListener(this);
}
private void postWindowStateChangedEvent(int newWindowState) {
if (getTarget() instanceof Frame) {
AWTAccessor.getFrameAccessor().setExtendedState((Frame) getTarget(), newWindowState);
}
WindowEvent stateChangedEvent =
new WindowEvent(getTarget(), WindowEvent.WINDOW_STATE_CHANGED, windowState, newWindowState);
postEvent(stateChangedEvent);
windowState = newWindowState;
updateSecurityWarningVisibility();
}
private static int getGraphicsConfigScreen(GraphicsConfiguration gc) {
// TODO: this method can be implemented in a more
// efficient way by forwarding to the delegate
GraphicsDevice gd = gc.getDevice();
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice[] gds = ge.getScreenDevices();
for (int i = 0; i < gds.length; i++) {
if (gds[i] == gd) {
return i;
}
}
// Should never happen if gc is a screen device config
return 0;
}
/*
* This method is called when window's graphics config is changed from
* the app code (e.g. when the window is made non-opaque) or when
* the window is moved to another screen by user.
*
* Returns true if the graphics config has been changed, false otherwise.
*/
private boolean setGraphicsConfig(GraphicsConfiguration gc) {
synchronized (getStateLock()) {
if (graphicsConfig == gc) {
return false;
}
// If window's graphics config is changed from the app code, the
// config correspond to the same device as before; when the window
// is moved by user, graphicsDevice is updated in notifyReshape().
// In either case, there's nothing to do with screenOn here
graphicsConfig = gc;
}
// SurfaceData is replaced later in updateGraphicsData()
return true;
}
/** Returns true if the GraphicsDevice has been changed, false otherwise. */
public boolean updateGraphicsDevice() {
GraphicsDevice newGraphicsDevice = platformWindow.getGraphicsDevice();
synchronized (getStateLock()) {
if (graphicsDevice == newGraphicsDevice) {
return false;
}
graphicsDevice = newGraphicsDevice;
}
final GraphicsConfiguration newGC = newGraphicsDevice.getDefaultConfiguration();
if (!setGraphicsConfig(newGC)) return false;
SunToolkit.executeOnEventHandlerThread(
getTarget(),
new Runnable() {
public void run() {
AWTAccessor.getComponentAccessor().setGraphicsConfiguration(getTarget(), newGC);
}
});
return true;
}
@Override
public final void displayChanged() {
if (updateGraphicsDevice()) {
updateMinimumSize();
}
// Replace surface unconditionally, because internal state of the
// GraphicsDevice could be changed.
replaceSurfaceData();
repaintPeer();
}
@Override
public final void paletteChanged() {
// components do not need to react to this event.
}
/*
* May be called by delegate to provide SD to Java2D code.
*/
public SurfaceData getSurfaceData() {
synchronized (surfaceDataLock) {
return surfaceData;
}
}
private void replaceSurfaceData() {
replaceSurfaceData(true);
}
private void replaceSurfaceData(final boolean blit) {
synchronized (surfaceDataLock) {
final SurfaceData oldData = getSurfaceData();
surfaceData = platformWindow.replaceSurfaceData();
final Rectangle size = getSize();
if (getSurfaceData() != null && oldData != getSurfaceData()) {
clearBackground(size.width, size.height);
}
if (blit) {
blitSurfaceData(oldData, getSurfaceData());
}
if (oldData != null && oldData != getSurfaceData()) {
// TODO: drop oldData for D3D/WGL pipelines
// This can only happen when this peer is being created
oldData.flush();
}
}
flushOnscreenGraphics();
}
private void blitSurfaceData(final SurfaceData src, final SurfaceData dst) {
// TODO blit. proof-of-concept
if (src != dst
&& src != null
&& dst != null
&& !(dst instanceof NullSurfaceData)
&& !(src instanceof NullSurfaceData)
&& src.getSurfaceType().equals(dst.getSurfaceType())
&& src.getDefaultScale() == dst.getDefaultScale()) {
final Rectangle size = src.getBounds();
final Blit blit = Blit.locate(src.getSurfaceType(), CompositeType.Src, dst.getSurfaceType());
if (blit != null) {
blit.Blit(src, dst, AlphaComposite.Src, null, 0, 0, 0, 0, size.width, size.height);
}
}
}
/**
* Request the window insets from the delegate and compares it with the current one. This method
* is mostly called by the delegate, e.g. when the window state is changed and insets should be
* recalculated.
*
* <p>This method may be called on the toolkit thread.
*/
public final boolean updateInsets(final Insets newInsets) {
synchronized (getStateLock()) {
if (insets.equals(newInsets)) {
return false;
}
insets = newInsets;
}
return true;
}
public static LWWindowPeer getWindowUnderCursor() {
return lastCommonMouseEventPeer != null ? lastCommonMouseEventPeer.getWindowPeerOrSelf() : null;
}
public static LWComponentPeer<?, ?> getPeerUnderCursor() {
return lastCommonMouseEventPeer;
}
/*
* Requests platform to set native focus on a frame/dialog.
* In case of a simple window, triggers appropriate java focus change.
*/
public boolean requestWindowFocus(CausedFocusEvent.Cause cause) {
if (focusLog.isLoggable(PlatformLogger.Level.FINE)) {
focusLog.fine("requesting native focus to " + this);
}
if (!focusAllowedFor()) {
focusLog.fine("focus is not allowed");
return false;
}
// if (platformWindow.rejectFocusRequest(cause)) {
// return false;
// }
AppContext targetAppContext = AWTAccessor.getComponentAccessor().getAppContext(getTarget());
KeyboardFocusManager kfm =
AWTAccessor.getKeyboardFocusManagerAccessor()
.getCurrentKeyboardFocusManager(targetAppContext);
Window currentActive = kfm.getActiveWindow();
Window opposite = LWKeyboardFocusManagerPeer.getInstance().getCurrentFocusedWindow();
// Make the owner active window.
if (isSimpleWindow()) {
focusLog.fine("This is a Simple Window.");
LWWindowPeer owner = getOwnerFrameDialog(this);
// If owner is not natively active, request native
// activation on it w/o sending events up to java.
if (owner != null && !owner.platformWindow.isActive()) {
if (focusLog.isLoggable(PlatformLogger.Level.FINE)) {
focusLog.fine("requesting native focus to the owner " + owner);
}
LWWindowPeer currentActivePeer =
currentActive == null
? null
: (LWWindowPeer) AWTAccessor.getComponentAccessor().getPeer(currentActive);
// Ensure the opposite is natively active and suppress sending events.
if (currentActivePeer != null && currentActivePeer.platformWindow.isActive()) {
if (focusLog.isLoggable(PlatformLogger.Level.FINE)) {
focusLog.fine("the opposite is " + currentActivePeer);
}
currentActivePeer.skipNextFocusChange = true;
}
owner.skipNextFocusChange = true;
owner.platformWindow.requestWindowFocus();
}
// DKFM will synthesize all the focus/activation events correctly.
changeFocusedWindow(true, opposite);
focusLog.fine("DKFM will synthesize all the focus/activation events correctly");
return true;
// In case the toplevel is active but not focused, change focus directly,
// as requesting native focus on it will not have effect.
} else if (getTarget() == currentActive && !getTarget().hasFocus()) {
changeFocusedWindow(true, opposite);
focusLog.fine("toplevel is active but not focused, change focus directly");
return true;
}
focusLog.fine("platformWindow.requestWindowFocus()");
return platformWindow.requestWindowFocus();
}
protected boolean focusAllowedFor() {
Window window = getTarget();
// TODO: check if modal blocked
boolean allowed =
(getBlocker() == null) && window.isVisible() && window.isEnabled() && isFocusableWindow();
focusLog.fine(
"Checking whether the focus is allowed ["
+ allowed
+ "] for "
+ window.getName()
+ "; blocker: "
+ ((getBlocker() == null) ? "null" : getBlocker().getClass().getName())
+ "; window.isVisible: "
+ window.isVisible()
+ "; window.isEnabled: "
+ window.isEnabled()
+ "; isFocusableWindow: "
+ isFocusableWindow());
return allowed;
}
private boolean isFocusableWindow() {
boolean focusable = targetFocusable;
if (isSimpleWindow()) {
LWWindowPeer ownerPeer = getOwnerFrameDialog(this);
if (ownerPeer == null) {
return false;
}
return focusable && ownerPeer.targetFocusable;
}
return focusable;
}
public boolean isSimpleWindow() {
Window window = getTarget();
return !(window instanceof Dialog || window instanceof Frame);
}
@Override
public void emulateActivation(boolean activate) {
changeFocusedWindow(activate, null);
}
private boolean isOneOfOwnersOf(LWWindowPeer peer) {
Window owner = (peer != null ? peer.getTarget().getOwner() : null);
while (owner != null) {
if ((LWWindowPeer) owner.getPeer() == this) {
return true;
}
owner = owner.getOwner();
}
return false;
}
/*
* Changes focused window on java level.
*/
protected void changeFocusedWindow(boolean becomesFocused, Window opposite) {
if (focusLog.isLoggable(PlatformLogger.Level.FINE)) {
focusLog.fine((becomesFocused ? "gaining" : "loosing") + " focus window: " + this);
}
if (skipNextFocusChange) {
focusLog.fine("skipping focus change");
skipNextFocusChange = false;
return;
}
if (!isFocusableWindow() && becomesFocused) {
focusLog.fine("the window is not focusable");
return;
}
if (becomesFocused) {
synchronized (getPeerTreeLock()) {
if (blocker != null) {
if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
focusLog.finest("the window is blocked by " + blocker);
}
return;
}
}
}
// Note, the method is not called:
// - when the opposite (gaining focus) window is an owned/owner window.
// - for a simple window in any case.
if (!becomesFocused && (isGrabbing() || this.isOneOfOwnersOf(grabbingWindow))) {
if (focusLog.isLoggable(PlatformLogger.Level.FINE)) {
focusLog.fine("ungrabbing on " + grabbingWindow);
}
// ungrab a simple window if its owner looses activation.
grabbingWindow.ungrab();
}
KeyboardFocusManagerPeer kfmPeer = LWKeyboardFocusManagerPeer.getInstance();
kfmPeer.setCurrentFocusedWindow(becomesFocused ? getTarget() : null);
int eventID = becomesFocused ? WindowEvent.WINDOW_GAINED_FOCUS : WindowEvent.WINDOW_LOST_FOCUS;
WindowEvent windowEvent =
new TimedWindowEvent(getTarget(), eventID, opposite, System.currentTimeMillis());
// TODO: wrap in SequencedEvent
postEvent(windowEvent);
}
/*
* Retrieves the owner of the peer.
* Note: this method returns the owner which can be activated, (i.e. the instance
* of Frame or Dialog may be returned).
*/
static LWWindowPeer getOwnerFrameDialog(LWWindowPeer peer) {
Window owner = (peer != null ? peer.getTarget().getOwner() : null);
while (owner != null && !(owner instanceof Frame || owner instanceof Dialog)) {
owner = owner.getOwner();
}
return owner == null ? null : (LWWindowPeer) AWTAccessor.getComponentAccessor().getPeer(owner);
}
/** Returns the foremost modal blocker of this window, or null. */
public LWWindowPeer getBlocker() {
synchronized (getPeerTreeLock()) {
LWWindowPeer blocker = this.blocker;
if (blocker == null) {
return null;
}
while (blocker.blocker != null) {
blocker = blocker.blocker;
}
return blocker;
}
}
@Override
public void enterFullScreenMode() {
platformWindow.enterFullScreenMode();
updateSecurityWarningVisibility();
}
@Override
public void exitFullScreenMode() {
platformWindow.exitFullScreenMode();
updateSecurityWarningVisibility();
}
public long getLayerPtr() {
return getPlatformWindow().getLayerPtr();
}
void grab() {
if (grabbingWindow != null && !isGrabbing()) {
grabbingWindow.ungrab();
}
grabbingWindow = this;
}
final void ungrab(boolean doPost) {
if (isGrabbing()) {
grabbingWindow = null;
if (doPost) {
postEvent(new UngrabEvent(getTarget()));
}
}
}
void ungrab() {
ungrab(true);
}
private boolean isGrabbing() {
return this == grabbingWindow;
}
public PeerType getPeerType() {
return peerType;
}
public void updateSecurityWarningVisibility() {
if (warningWindow == null) {
return;
}
if (!isVisible()) {
return; // The warning window should already be hidden.
}
boolean show = false;
if (!platformWindow.isFullScreenMode()) {
if (isVisible()) {
if (LWKeyboardFocusManagerPeer.getInstance().getCurrentFocusedWindow() == getTarget()) {
show = true;
}
if (platformWindow.isUnderMouse() || warningWindow.isUnderMouse()) {
show = true;
}
}
}
warningWindow.setVisible(show, true);
}
@Override
public String toString() {
return super.toString() + " [target is " + getTarget() + "]";
}
}
public class XEmbeddedFramePeer extends XFramePeer {
private static final PlatformLogger xembedLog =
PlatformLogger.getLogger("sun.awt.X11.xembed.XEmbeddedFramePeer");
LinkedList<AWTKeyStroke> strokes;
XEmbedClientHelper embedder; // Caution - can be null if XEmbed is not supported
public XEmbeddedFramePeer(EmbeddedFrame target) {
// Don't specify PARENT_WINDOW param here. Instead we reparent
// this embedded frame peer to the proper parent window after
// an XEventDispatcher is registered to handle XEmbed events
super(
new XCreateWindowParams(
new Object[] {
TARGET, target,
VISIBLE, Boolean.TRUE,
EMBEDDED, Boolean.TRUE
}));
}
public void preInit(XCreateWindowParams params) {
super.preInit(params);
strokes = new LinkedList<AWTKeyStroke>();
if (supportsXEmbed()) {
embedder = new XEmbedClientHelper();
}
}
void postInit(XCreateWindowParams params) {
super.postInit(params);
if (embedder != null) {
// install X11 event dispatcher
embedder.setClient(this);
// reparent to XEmbed server
embedder.install();
} else if (getParentWindowHandle() != 0) {
XToolkit.awtLock();
try {
XlibWrapper.XReparentWindow(
XToolkit.getDisplay(), getWindow(), getParentWindowHandle(), 0, 0);
} finally {
XToolkit.awtUnlock();
}
}
}
@Override
public void dispose() {
if (embedder != null) {
// uninstall X11 event dispatcher
embedder.setClient(null);
}
super.dispose();
}
public void updateMinimumSize() {}
protected String getWMName() {
return "JavaEmbeddedFrame";
}
final long getParentWindowHandle() {
return ((XEmbeddedFrame) target).handle;
}
boolean supportsXEmbed() {
return ((EmbeddedFrame) target).supportsXEmbed();
}
public boolean requestWindowFocus(long time, boolean timeProvided) {
// Should check for active state of host application
if (embedder != null && embedder.isActive()) {
xembedLog.fine("Requesting focus from embedding host");
return embedder.requestFocus();
} else {
xembedLog.fine("Requesting focus from X");
return super.requestWindowFocus(time, timeProvided);
}
}
protected void requestInitialFocus() {
if (embedder != null && supportsXEmbed()) {
embedder.requestFocus();
} else {
super.requestInitialFocus();
}
}
protected boolean isEventDisabled(XEvent e) {
if (embedder != null && embedder.isActive()) {
switch (e.get_type()) {
case XConstants.FocusIn:
case XConstants.FocusOut:
return true;
}
}
return super.isEventDisabled(e);
}
public void handleConfigureNotifyEvent(XEvent xev) {
assert (SunToolkit.isAWTLockHeldByCurrentThread());
XConfigureEvent xe = xev.get_xconfigure();
if (xembedLog.isLoggable(PlatformLogger.Level.FINE)) {
xembedLog.fine(xe.toString());
}
// fix for 5063031
// if we use super.handleConfigureNotifyEvent() we would get wrong
// size and position because embedded frame really is NOT a decorated one
checkIfOnNewScreen(
toGlobal(new Rectangle(xe.get_x(), xe.get_y(), xe.get_width(), xe.get_height())));
Rectangle oldBounds = getBounds();
synchronized (getStateLock()) {
x = xe.get_x();
y = xe.get_y();
width = xe.get_width();
height = xe.get_height();
dimensions.setClientSize(width, height);
dimensions.setLocation(x, y);
}
if (!getLocation().equals(oldBounds.getLocation())) {
handleMoved(dimensions);
}
reconfigureContentWindow(dimensions);
}
protected void traverseOutForward() {
if (embedder != null && embedder.isActive()) {
if (embedder.isApplicationActive()) {
xembedLog.fine("Traversing out Forward");
embedder.traverseOutForward();
}
}
}
protected void traverseOutBackward() {
if (embedder != null && embedder.isActive()) {
if (embedder.isApplicationActive()) {
xembedLog.fine("Traversing out Backward");
embedder.traverseOutBackward();
}
}
}
// don't use getLocationOnScreen() inherited from XDecoratedPeer
public Point getLocationOnScreen() {
XToolkit.awtLock();
try {
return toGlobal(0, 0);
} finally {
XToolkit.awtUnlock();
}
}
// don't use getBounds() inherited from XDecoratedPeer
public Rectangle getBounds() {
return new Rectangle(x, y, width, height);
}
public void setBoundsPrivate(int x, int y, int width, int height) {
setBounds(x, y, width, height, SET_BOUNDS | NO_EMBEDDED_CHECK);
}
public Rectangle getBoundsPrivate() {
int x = 0, y = 0;
int w = 0, h = 0;
XWindowAttributes attr = new XWindowAttributes();
XToolkit.awtLock();
try {
XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(), getWindow(), attr.pData);
x = attr.get_x();
y = attr.get_y();
w = attr.get_width();
h = attr.get_height();
} finally {
XToolkit.awtUnlock();
}
attr.dispose();
return new Rectangle(x, y, w, h);
}
void registerAccelerator(AWTKeyStroke stroke) {
if (stroke == null) return;
strokes.add(stroke);
if (embedder != null && embedder.isActive()) {
embedder.registerAccelerator(stroke, strokes.size() - 1);
}
}
void unregisterAccelerator(AWTKeyStroke stroke) {
if (stroke == null) return;
if (embedder != null && embedder.isActive()) {
int index = strokes.indexOf(stroke);
embedder.unregisterAccelerator(index);
}
}
void notifyStarted() {
// Register accelerators
if (embedder != null && embedder.isActive()) {
int i = 0;
Iterator<AWTKeyStroke> iter = strokes.iterator();
while (iter.hasNext()) {
embedder.registerAccelerator(iter.next(), i++);
}
}
// Now we know that the the embedder is an XEmbed server, so we
// reregister the drop target to enable XDnD protocol support via
// XEmbed.
updateDropTarget();
}
void notifyStopped() {
if (embedder != null && embedder.isActive()) {
for (int i = strokes.size() - 1; i >= 0; i--) {
embedder.unregisterAccelerator(i);
}
}
}
long getFocusTargetWindow() {
return getWindow();
}
boolean isXEmbedActive() {
return embedder != null && embedder.isActive();
}
public int getAbsoluteX() {
Point absoluteLoc =
XlibUtil.translateCoordinates(
getWindow(), XToolkit.getDefaultRootWindow(), new Point(0, 0));
return absoluteLoc != null ? absoluteLoc.x : 0;
}
public int getAbsoluteY() {
Point absoluteLoc =
XlibUtil.translateCoordinates(
getWindow(), XToolkit.getDefaultRootWindow(), new Point(0, 0));
return absoluteLoc != null ? absoluteLoc.y : 0;
}
public int getWidth() {
return width;
}
public int getHeight() {
return height;
}
public Dimension getSize() {
return new Dimension(width, height);
}
// override XWindowPeer's method to let the embedded frame to block
// the containing window
public void setModalBlocked(Dialog blocker, boolean blocked) {
super.setModalBlocked(blocker, blocked);
EmbeddedFrame frame = (EmbeddedFrame) target;
frame.notifyModalBlocked(blocker, blocked);
}
public void synthesizeFocusInOut(boolean doFocus) {
XFocusChangeEvent xev = new XFocusChangeEvent();
XToolkit.awtLock();
try {
xev.set_type(doFocus ? FocusIn : FocusOut);
xev.set_window(getFocusProxy().getWindow());
xev.set_mode(NotifyNormal);
XlibWrapper.XSendEvent(
XToolkit.getDisplay(), getFocusProxy().getWindow(), false, NoEventMask, xev.pData);
} finally {
XToolkit.awtUnlock();
xev.dispose();
}
}
}
public void put(URI uri, Map<String, List<String>> responseHeaders) throws IOException {
// pre-condition check
if (uri == null || responseHeaders == null) {
throw new IllegalArgumentException("Argument is null");
}
// if there's no default CookieStore, no need to remember any cookie
if (cookieJar == null) return;
PlatformLogger logger = PlatformLogger.getLogger("java.net.CookieManager");
for (String headerKey : responseHeaders.keySet()) {
// RFC 2965 3.2.2, key must be 'Set-Cookie2'
// we also accept 'Set-Cookie' here for backward compatibility
if (headerKey == null
|| !(headerKey.equalsIgnoreCase("Set-Cookie2")
|| headerKey.equalsIgnoreCase("Set-Cookie"))) {
continue;
}
for (String headerValue : responseHeaders.get(headerKey)) {
try {
List<HttpCookie> cookies;
try {
cookies = HttpCookie.parse(headerValue);
} catch (IllegalArgumentException e) {
// Bogus header, make an empty list and log the error
cookies = java.util.Collections.EMPTY_LIST;
if (logger.isLoggable(PlatformLogger.SEVERE)) {
logger.severe("Invalid cookie for " + uri + ": " + headerValue);
}
}
for (HttpCookie cookie : cookies) {
if (cookie.getPath() == null) {
// If no path is specified, then by default
// the path is the directory of the page/doc
String path = uri.getPath();
if (!path.endsWith("/")) {
int i = path.lastIndexOf("/");
if (i > 0) {
path = path.substring(0, i + 1);
} else {
path = "/";
}
}
cookie.setPath(path);
}
// As per RFC 2965, section 3.3.1:
// Domain Defaults to the effective request-host. (Note that because
// there is no dot at the beginning of effective request-host,
// the default Domain can only domain-match itself.)
if (cookie.getDomain() == null) {
cookie.setDomain(uri.getHost());
}
String ports = cookie.getPortlist();
if (ports != null) {
int port = uri.getPort();
if (port == -1) {
port = "https".equals(uri.getScheme()) ? 443 : 80;
}
if (ports.isEmpty()) {
// Empty port list means this should be restricted
// to the incoming URI port
cookie.setPortlist("" + port);
if (shouldAcceptInternal(uri, cookie)) {
cookieJar.add(uri, cookie);
}
} else {
// Only store cookies with a port list
// IF the URI port is in that list, as per
// RFC 2965 section 3.3.2
if (isInPortList(ports, port) && shouldAcceptInternal(uri, cookie)) {
cookieJar.add(uri, cookie);
}
}
} else {
if (shouldAcceptInternal(uri, cookie)) {
cookieJar.add(uri, cookie);
}
}
}
} catch (IllegalArgumentException e) {
// invalid set-cookie header string
// no-op
}
}
}
}
public class WWindowPeer extends WPanelPeer implements WindowPeer, DisplayChangedListener {
private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.windows.WWindowPeer");
private static final PlatformLogger screenLog =
PlatformLogger.getLogger("sun.awt.windows.screen.WWindowPeer");
// we can't use WDialogPeer as blocker may be an instance of WPrintDialogPeer that
// extends WWindowPeer, not WDialogPeer
private WWindowPeer modalBlocker = null;
private boolean isOpaque;
private TranslucentWindowPainter painter;
/*
* A key used for storing a list of active windows in AppContext. The value
* is a list of windows, sorted by the time of activation: later a window is
* activated, greater its index is in the list.
*/
private static final StringBuffer ACTIVE_WINDOWS_KEY = new StringBuffer("active_windows_list");
/*
* Listener for 'activeWindow' KFM property changes. It is added to each
* AppContext KFM. See ActiveWindowListener inner class below.
*/
private static PropertyChangeListener activeWindowListener = new ActiveWindowListener();
/*
* The object is a listener for the AppContext.GUI_DISPOSED property.
*/
private static final PropertyChangeListener guiDisposedListener = new GuiDisposedListener();
/*
* Called (on the Toolkit thread) before the appropriate
* WindowStateEvent is posted to the EventQueue.
*/
private WindowListener windowListener;
/** Initialize JNI field IDs */
private static native void initIDs();
static {
initIDs();
}
// WComponentPeer overrides
@SuppressWarnings("unchecked")
protected void disposeImpl() {
AppContext appContext = SunToolkit.targetToAppContext(target);
synchronized (appContext) {
List<WWindowPeer> l = (List<WWindowPeer>) appContext.get(ACTIVE_WINDOWS_KEY);
if (l != null) {
l.remove(this);
}
}
// Remove ourself from the Map of DisplayChangeListeners
GraphicsConfiguration gc = getGraphicsConfiguration();
((Win32GraphicsDevice) gc.getDevice()).removeDisplayChangedListener(this);
synchronized (getStateLock()) {
TranslucentWindowPainter currentPainter = painter;
if (currentPainter != null) {
currentPainter.flush();
// don't set the current one to null here; reduces the chances of
// MT issues (like NPEs)
}
}
super.disposeImpl();
}
// WindowPeer implementation
public void toFront() {
updateFocusableWindowState();
_toFront();
}
native void _toFront();
public native void toBack();
public native void setAlwaysOnTopNative(boolean value);
public void setAlwaysOnTop(boolean value) {
if ((value && ((Window) target).isVisible()) || !value) {
setAlwaysOnTopNative(value);
}
}
public void updateAlwaysOnTopState() {
setAlwaysOnTop(((Window) target).isAlwaysOnTop());
}
public void updateFocusableWindowState() {
setFocusableWindow(((Window) target).isFocusableWindow());
}
native void setFocusableWindow(boolean value);
// FramePeer & DialogPeer partial shared implementation
public void setTitle(String title) {
// allow a null title to pass as an empty string.
if (title == null) {
title = "";
}
_setTitle(title);
}
native void _setTitle(String title);
public void setResizable(boolean resizable) {
_setResizable(resizable);
}
public native void _setResizable(boolean resizable);
// Toolkit & peer internals
WWindowPeer(Window target) {
super(target);
}
void initialize() {
super.initialize();
updateInsets(insets_);
Font f = ((Window) target).getFont();
if (f == null) {
f = defaultFont;
((Window) target).setFont(f);
setFont(f);
}
// Express our interest in display changes
GraphicsConfiguration gc = getGraphicsConfiguration();
((Win32GraphicsDevice) gc.getDevice()).addDisplayChangedListener(this);
initActiveWindowsTracking((Window) target);
updateIconImages();
Shape shape = ((Window) target).getShape();
if (shape != null) {
applyShape(Region.getInstance(shape, null));
}
float opacity = ((Window) target).getOpacity();
if (opacity < 1.0f) {
setOpacity(opacity);
}
synchronized (getStateLock()) {
// default value of a boolean field is 'false', so set isOpaque to
// true here explicitly
this.isOpaque = true;
setOpaque(((Window) target).isOpaque());
}
}
native void createAwtWindow(WComponentPeer parent);
private volatile Window.Type windowType = Window.Type.NORMAL;
// This method must be called for Window, Dialog, and Frame before creating
// the hwnd
void preCreate(WComponentPeer parent) {
windowType = ((Window) target).getType();
}
void create(WComponentPeer parent) {
preCreate(parent);
createAwtWindow(parent);
}
@Override
final WComponentPeer getNativeParent() {
final Container owner = ((Window) target).getOwner();
return (WComponentPeer) WToolkit.targetToPeer(owner);
}
// should be overriden in WDialogPeer
protected void realShow() {
super.show();
}
public void show() {
updateFocusableWindowState();
boolean alwaysOnTop = ((Window) target).isAlwaysOnTop();
// Fix for 4868278.
// If we create a window with a specific GraphicsConfig, and then move it with
// setLocation() or setBounds() to another one before its peer has been created,
// then calling Window.getGraphicsConfig() returns wrong config. That may lead
// to some problems like wrong-placed tooltips. It is caused by calling
// super.displayChanged() in WWindowPeer.displayChanged() regardless of whether
// GraphicsDevice was really changed, or not. So we need to track it here.
updateGC();
realShow();
updateMinimumSize();
if (((Window) target).isAlwaysOnTopSupported() && alwaysOnTop) {
setAlwaysOnTop(alwaysOnTop);
}
synchronized (getStateLock()) {
if (!isOpaque) {
updateWindow(true);
}
}
}
// Synchronize the insets members (here & in helper) with actual window
// state.
native void updateInsets(Insets i);
static native int getSysMinWidth();
static native int getSysMinHeight();
static native int getSysIconWidth();
static native int getSysIconHeight();
static native int getSysSmIconWidth();
static native int getSysSmIconHeight();
/**
* windows/classes/sun/awt/windows/ Creates native icon from specified raster data and updates
* icon for window and all descendant windows that inherit icon. Raster data should be passed in
* the ARGB form. Note that raster data format was changed to provide support for XP icons with
* alpha-channel
*/
native void setIconImagesData(
int[] iconRaster, int w, int h, int[] smallIconRaster, int smw, int smh);
synchronized native void reshapeFrame(int x, int y, int width, int height);
public boolean requestWindowFocus(CausedFocusEvent.Cause cause) {
if (!focusAllowedFor()) {
return false;
}
return requestWindowFocus(cause == CausedFocusEvent.Cause.MOUSE_EVENT);
}
public native boolean requestWindowFocus(boolean isMouseEventCause);
public boolean focusAllowedFor() {
Window window = (Window) this.target;
if (!window.isVisible() || !window.isEnabled() || !window.isFocusableWindow()) {
return false;
}
if (isModalBlocked()) {
return false;
}
return true;
}
public void hide() {
WindowListener listener = windowListener;
if (listener != null) {
// We're not getting WINDOW_CLOSING from the native code when hiding
// the window programmatically. So, create it and notify the listener.
listener.windowClosing(new WindowEvent((Window) target, WindowEvent.WINDOW_CLOSING));
}
super.hide();
}
// WARNING: it's called on the Toolkit thread!
void preprocessPostEvent(AWTEvent event) {
if (event instanceof WindowEvent) {
WindowListener listener = windowListener;
if (listener != null) {
switch (event.getID()) {
case WindowEvent.WINDOW_CLOSING:
listener.windowClosing((WindowEvent) event);
break;
case WindowEvent.WINDOW_ICONIFIED:
listener.windowIconified((WindowEvent) event);
break;
}
}
}
}
synchronized void addWindowListener(WindowListener l) {
windowListener = AWTEventMulticaster.add(windowListener, l);
}
synchronized void removeWindowListener(WindowListener l) {
windowListener = AWTEventMulticaster.remove(windowListener, l);
}
public void updateMinimumSize() {
Dimension minimumSize = null;
if (((Component) target).isMinimumSizeSet()) {
minimumSize = ((Component) target).getMinimumSize();
}
if (minimumSize != null) {
int msw = getSysMinWidth();
int msh = getSysMinHeight();
int w = (minimumSize.width >= msw) ? minimumSize.width : msw;
int h = (minimumSize.height >= msh) ? minimumSize.height : msh;
setMinSize(w, h);
} else {
setMinSize(0, 0);
}
}
public void updateIconImages() {
java.util.List<Image> imageList = ((Window) target).getIconImages();
if (imageList == null || imageList.size() == 0) {
setIconImagesData(null, 0, 0, null, 0, 0);
} else {
int w = getSysIconWidth();
int h = getSysIconHeight();
int smw = getSysSmIconWidth();
int smh = getSysSmIconHeight();
DataBufferInt iconData = SunToolkit.getScaledIconData(imageList, w, h);
DataBufferInt iconSmData = SunToolkit.getScaledIconData(imageList, smw, smh);
if (iconData != null && iconSmData != null) {
setIconImagesData(iconData.getData(), w, h, iconSmData.getData(), smw, smh);
} else {
setIconImagesData(null, 0, 0, null, 0, 0);
}
}
}
native void setMinSize(int width, int height);
/*
* ---- MODALITY SUPPORT ----
*/
/**
* Some modality-related code here because WFileDialogPeer, WPrintDialogPeer and WPageDialogPeer
* are descendants of WWindowPeer, not WDialogPeer
*/
public boolean isModalBlocked() {
return modalBlocker != null;
}
@SuppressWarnings("deprecation")
public void setModalBlocked(Dialog dialog, boolean blocked) {
synchronized (
((Component) getTarget()).getTreeLock()) // State lock should always be after awtLock
{
// use WWindowPeer instead of WDialogPeer because of FileDialogs and PrintDialogs
WWindowPeer blockerPeer = (WWindowPeer) dialog.getPeer();
if (blocked) {
modalBlocker = blockerPeer;
// handle native dialogs separately, as they may have not
// got HWND yet; modalEnable/modalDisable is called from
// their setHWnd() methods
if (blockerPeer instanceof WFileDialogPeer) {
((WFileDialogPeer) blockerPeer).blockWindow(this);
} else if (blockerPeer instanceof WPrintDialogPeer) {
((WPrintDialogPeer) blockerPeer).blockWindow(this);
} else {
modalDisable(dialog, blockerPeer.getHWnd());
}
} else {
modalBlocker = null;
if (blockerPeer instanceof WFileDialogPeer) {
((WFileDialogPeer) blockerPeer).unblockWindow(this);
} else if (blockerPeer instanceof WPrintDialogPeer) {
((WPrintDialogPeer) blockerPeer).unblockWindow(this);
} else {
modalEnable(dialog);
}
}
}
}
native void modalDisable(Dialog blocker, long blockerHWnd);
native void modalEnable(Dialog blocker);
/*
* Returns all the ever active windows from the current AppContext.
* The list is sorted by the time of activation, so the latest
* active window is always at the end.
*/
@SuppressWarnings("unchecked")
public static long[] getActiveWindowHandles() {
AppContext appContext = AppContext.getAppContext();
synchronized (appContext) {
List<WWindowPeer> l = (List<WWindowPeer>) appContext.get(ACTIVE_WINDOWS_KEY);
if (l == null) {
return null;
}
long[] result = new long[l.size()];
for (int j = 0; j < l.size(); j++) {
result[j] = l.get(j).getHWnd();
}
return result;
}
}
/*
* ----DISPLAY CHANGE SUPPORT----
*/
/*
* Called from native code when we have been dragged onto another screen.
*/
void draggedToNewScreen() {
SunToolkit.executeOnEventHandlerThread(
(Component) target,
new Runnable() {
public void run() {
displayChanged();
}
});
}
public void updateGC() {
int scrn = getScreenImOn();
if (screenLog.isLoggable(PlatformLogger.Level.FINER)) {
log.finer("Screen number: " + scrn);
}
// get current GD
Win32GraphicsDevice oldDev = (Win32GraphicsDevice) winGraphicsConfig.getDevice();
Win32GraphicsDevice newDev;
GraphicsDevice devs[] = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices();
// Occasionally during device addition/removal getScreenImOn can return
// a non-existing screen number. Use the default device in this case.
if (scrn >= devs.length) {
newDev =
(Win32GraphicsDevice)
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
} else {
newDev = (Win32GraphicsDevice) devs[scrn];
}
// Set winGraphicsConfig to the default GC for the monitor this Window
// is now mostly on.
winGraphicsConfig = (Win32GraphicsConfig) newDev.getDefaultConfiguration();
if (screenLog.isLoggable(PlatformLogger.Level.FINE)) {
if (winGraphicsConfig == null) {
screenLog.fine("Assertion (winGraphicsConfig != null) failed");
}
}
// if on a different display, take off old GD and put on new GD
if (oldDev != newDev) {
oldDev.removeDisplayChangedListener(this);
newDev.addDisplayChangedListener(this);
}
AWTAccessor.getComponentAccessor()
.setGraphicsConfiguration((Component) target, winGraphicsConfig);
}
/**
* From the DisplayChangedListener interface.
*
* <p>This method handles a display change - either when the display settings are changed, or when
* the window has been dragged onto a different display. Called after a change in the display
* mode. This event triggers replacing the surfaceData object (since that object reflects the
* current display depth information, which has just changed).
*/
public void displayChanged() {
updateGC();
}
/** Part of the DisplayChangedListener interface: components do not need to react to this event */
public void paletteChanged() {}
private native int getScreenImOn();
// Used in Win32GraphicsDevice.
public final native void setFullScreenExclusiveModeState(boolean state);
/*
* ----END DISPLAY CHANGE SUPPORT----
*/
public void grab() {
nativeGrab();
}
public void ungrab() {
nativeUngrab();
}
private native void nativeGrab();
private native void nativeUngrab();
private final boolean hasWarningWindow() {
return ((Window) target).getWarningString() != null;
}
boolean isTargetUndecorated() {
return true;
}
// These are the peer bounds. They get updated at:
// 1. the WWindowPeer.setBounds() method.
// 2. the native code (on WM_SIZE/WM_MOVE)
private volatile int sysX = 0;
private volatile int sysY = 0;
private volatile int sysW = 0;
private volatile int sysH = 0;
public native void repositionSecurityWarning();
@Override
public void setBounds(int x, int y, int width, int height, int op) {
sysX = x;
sysY = y;
sysW = width;
sysH = height;
super.setBounds(x, y, width, height, op);
}
@Override
public void print(Graphics g) {
// We assume we print the whole frame,
// so we expect no clip was set previously
Shape shape = AWTAccessor.getWindowAccessor().getShape((Window) target);
if (shape != null) {
g.setClip(shape);
}
super.print(g);
}
@SuppressWarnings("deprecation")
private void replaceSurfaceDataRecursively(Component c) {
if (c instanceof Container) {
for (Component child : ((Container) c).getComponents()) {
replaceSurfaceDataRecursively(child);
}
}
ComponentPeer cp = c.getPeer();
if (cp instanceof WComponentPeer) {
((WComponentPeer) cp).replaceSurfaceDataLater();
}
}
public final Graphics getTranslucentGraphics() {
synchronized (getStateLock()) {
return isOpaque ? null : painter.getBackBuffer(false).getGraphics();
}
}
@Override
public void setBackground(Color c) {
super.setBackground(c);
synchronized (getStateLock()) {
if (!isOpaque && ((Window) target).isVisible()) {
updateWindow(true);
}
}
}
private native void setOpacity(int iOpacity);
private float opacity = 1.0f;
public void setOpacity(float opacity) {
if (!((SunToolkit) ((Window) target).getToolkit()).isWindowOpacitySupported()) {
return;
}
if (opacity < 0.0f || opacity > 1.0f) {
throw new IllegalArgumentException(
"The value of opacity should be in the range [0.0f .. 1.0f].");
}
if (((this.opacity == 1.0f && opacity < 1.0f) || (this.opacity < 1.0f && opacity == 1.0f))
&& !Win32GraphicsEnvironment.isVistaOS()) {
// non-Vista OS: only replace the surface data if opacity status
// changed (see WComponentPeer.isAccelCapable() for more)
replaceSurfaceDataRecursively((Component) getTarget());
}
this.opacity = opacity;
final int maxOpacity = 0xff;
int iOpacity = (int) (opacity * maxOpacity);
if (iOpacity < 0) {
iOpacity = 0;
}
if (iOpacity > maxOpacity) {
iOpacity = maxOpacity;
}
setOpacity(iOpacity);
synchronized (getStateLock()) {
if (!isOpaque && ((Window) target).isVisible()) {
updateWindow(true);
}
}
}
private native void setOpaqueImpl(boolean isOpaque);
public void setOpaque(boolean isOpaque) {
synchronized (getStateLock()) {
if (this.isOpaque == isOpaque) {
return;
}
}
Window target = (Window) getTarget();
if (!isOpaque) {
SunToolkit sunToolkit = (SunToolkit) target.getToolkit();
if (!sunToolkit.isWindowTranslucencySupported()
|| !sunToolkit.isTranslucencyCapable(target.getGraphicsConfiguration())) {
return;
}
}
boolean isVistaOS = Win32GraphicsEnvironment.isVistaOS();
if (this.isOpaque != isOpaque && !isVistaOS) {
// non-Vista OS: only replace the surface data if the opacity
// status changed (see WComponentPeer.isAccelCapable() for more)
replaceSurfaceDataRecursively(target);
}
synchronized (getStateLock()) {
this.isOpaque = isOpaque;
setOpaqueImpl(isOpaque);
if (isOpaque) {
TranslucentWindowPainter currentPainter = painter;
if (currentPainter != null) {
currentPainter.flush();
painter = null;
}
} else {
painter = TranslucentWindowPainter.createInstance(this);
}
}
if (isVistaOS) {
// On Vista: setting the window non-opaque makes the window look
// rectangular, though still catching the mouse clicks within
// its shape only. To restore the correct visual appearance
// of the window (i.e. w/ the correct shape) we have to reset
// the shape.
Shape shape = target.getShape();
if (shape != null) {
target.setShape(shape);
}
}
if (target.isVisible()) {
updateWindow(true);
}
}
public native void updateWindowImpl(int[] data, int width, int height);
public void updateWindow() {
updateWindow(false);
}
private void updateWindow(boolean repaint) {
Window w = (Window) target;
synchronized (getStateLock()) {
if (isOpaque || !w.isVisible() || (w.getWidth() <= 0) || (w.getHeight() <= 0)) {
return;
}
TranslucentWindowPainter currentPainter = painter;
if (currentPainter != null) {
currentPainter.updateWindow(repaint);
} else if (log.isLoggable(PlatformLogger.Level.FINER)) {
log.finer("Translucent window painter is null in updateWindow");
}
}
}
/*
* The method maps the list of the active windows to the window's AppContext,
* then the method registers ActiveWindowListener, GuiDisposedListener listeners;
* it executes the initilialization only once per AppContext.
*/
@SuppressWarnings("unchecked")
private static void initActiveWindowsTracking(Window w) {
AppContext appContext = AppContext.getAppContext();
synchronized (appContext) {
List<WWindowPeer> l = (List<WWindowPeer>) appContext.get(ACTIVE_WINDOWS_KEY);
if (l == null) {
l = new LinkedList<WWindowPeer>();
appContext.put(ACTIVE_WINDOWS_KEY, l);
appContext.addPropertyChangeListener(AppContext.GUI_DISPOSED, guiDisposedListener);
KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
kfm.addPropertyChangeListener("activeWindow", activeWindowListener);
}
}
}
/*
* The GuiDisposedListener class listens for the AppContext.GUI_DISPOSED property,
* it removes the list of the active windows from the disposed AppContext and
* unregisters ActiveWindowListener listener.
*/
private static class GuiDisposedListener implements PropertyChangeListener {
public void propertyChange(PropertyChangeEvent e) {
boolean isDisposed = (Boolean) e.getNewValue();
if (isDisposed != true) {
if (log.isLoggable(PlatformLogger.Level.FINE)) {
log.fine(" Assertion (newValue != true) failed for AppContext.GUI_DISPOSED ");
}
}
AppContext appContext = AppContext.getAppContext();
synchronized (appContext) {
appContext.remove(ACTIVE_WINDOWS_KEY);
appContext.removePropertyChangeListener(AppContext.GUI_DISPOSED, this);
KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
kfm.removePropertyChangeListener("activeWindow", activeWindowListener);
}
}
}
/*
* Static inner class, listens for 'activeWindow' KFM property changes and
* updates the list of active windows per AppContext, so the latest active
* window is always at the end of the list. The list is stored in AppContext.
*/
@SuppressWarnings(value = {"deprecation", "unchecked"})
private static class ActiveWindowListener implements PropertyChangeListener {
public void propertyChange(PropertyChangeEvent e) {
Window w = (Window) e.getNewValue();
if (w == null) {
return;
}
AppContext appContext = SunToolkit.targetToAppContext(w);
synchronized (appContext) {
WWindowPeer wp = (WWindowPeer) w.getPeer();
// add/move wp to the end of the list
List<WWindowPeer> l = (List<WWindowPeer>) appContext.get(ACTIVE_WINDOWS_KEY);
if (l != null) {
l.remove(wp);
l.add(wp);
}
}
}
}
}
/**
* This utility class is used to suspend execution on a thread while still allowing {@code
* EventDispatchThread} to dispatch events. The API methods of the class are thread-safe.
*
* @author Anton Tarasov, Artem Ananiev
* @since 1.7
*/
class WaitDispatchSupport implements SecondaryLoop {
private static final PlatformLogger log =
PlatformLogger.getLogger("java.awt.event.WaitDispatchSupport");
private EventDispatchThread dispatchThread;
private EventFilter filter;
private volatile Conditional extCondition;
private volatile Conditional condition;
private long interval;
// Use a shared daemon timer to serve all the WaitDispatchSupports
private static Timer timer;
// When this WDS expires, we cancel the timer task leaving the
// shared timer up and running
private TimerTask timerTask;
private AtomicBoolean keepBlockingEDT = new AtomicBoolean(false);
private AtomicBoolean keepBlockingCT = new AtomicBoolean(false);
private static synchronized void initializeTimer() {
if (timer == null) {
timer = new Timer("AWT-WaitDispatchSupport-Timer", true);
}
}
/**
* Creates a {@code WaitDispatchSupport} instance to serve the given event dispatch thread.
*
* @param dispatchThread An event dispatch thread that should not stop dispatching events while
* waiting
* @since 1.7
*/
public WaitDispatchSupport(EventDispatchThread dispatchThread) {
this(dispatchThread, null);
}
/**
* Creates a {@code WaitDispatchSupport} instance to serve the given event dispatch thread.
*
* @param dispatchThread An event dispatch thread that should not stop dispatching events while
* waiting
* @param extCondition A conditional object used to determine if the loop should be terminated
* @since 1.7
*/
public WaitDispatchSupport(EventDispatchThread dispatchThread, Conditional extCond) {
if (dispatchThread == null) {
throw new IllegalArgumentException("The dispatchThread can not be null");
}
this.dispatchThread = dispatchThread;
this.extCondition = extCond;
this.condition =
new Conditional() {
@Override
public boolean evaluate() {
if (log.isLoggable(PlatformLogger.Level.FINEST)) {
log.finest(
"evaluate(): blockingEDT="
+ keepBlockingEDT.get()
+ ", blockingCT="
+ keepBlockingCT.get());
}
boolean extEvaluate = (extCondition != null) ? extCondition.evaluate() : true;
if (!keepBlockingEDT.get() || !extEvaluate) {
if (timerTask != null) {
timerTask.cancel();
timerTask = null;
}
return false;
}
return true;
}
};
}
/**
* Creates a {@code WaitDispatchSupport} instance to serve the given event dispatch thread.
*
* <p>The {@link EventFilter} is set on the {@code dispatchThread} while waiting. The filter is
* removed on completion of the waiting process.
*
* <p>
*
* @param dispatchThread An event dispatch thread that should not stop dispatching events while
* waiting
* @param filter {@code EventFilter} to be set
* @param interval A time interval to wait for. Note that when the waiting process takes place on
* EDT there is no guarantee to stop it in the given time
* @since 1.7
*/
public WaitDispatchSupport(
EventDispatchThread dispatchThread,
Conditional extCondition,
EventFilter filter,
long interval) {
this(dispatchThread, extCondition);
this.filter = filter;
if (interval < 0) {
throw new IllegalArgumentException("The interval value must be >= 0");
}
this.interval = interval;
if (interval != 0) {
initializeTimer();
}
}
/** @inheritDoc */
@Override
public boolean enter() {
if (log.isLoggable(PlatformLogger.Level.FINE)) {
log.fine(
"enter(): blockingEDT=" + keepBlockingEDT.get() + ", blockingCT=" + keepBlockingCT.get());
}
if (!keepBlockingEDT.compareAndSet(false, true)) {
log.fine("The secondary loop is already running, aborting");
return false;
}
final Runnable run =
new Runnable() {
public void run() {
log.fine("Starting a new event pump");
if (filter == null) {
dispatchThread.pumpEvents(condition);
} else {
dispatchThread.pumpEventsForFilter(condition, filter);
}
}
};
// We have two mechanisms for blocking: if we're on the
// dispatch thread, start a new event pump; if we're
// on any other thread, call wait() on the treelock
Thread currentThread = Thread.currentThread();
if (currentThread == dispatchThread) {
if (log.isLoggable(PlatformLogger.Level.FINEST)) {
log.finest("On dispatch thread: " + dispatchThread);
}
if (interval != 0) {
if (log.isLoggable(PlatformLogger.Level.FINEST)) {
log.finest("scheduling the timer for " + interval + " ms");
}
timer.schedule(
timerTask =
new TimerTask() {
@Override
public void run() {
if (keepBlockingEDT.compareAndSet(true, false)) {
wakeupEDT();
}
}
},
interval);
}
// Dispose SequencedEvent we are dispatching on the the current
// AppContext, to prevent us from hang - see 4531693 for details
SequencedEvent currentSE =
KeyboardFocusManager.getCurrentKeyboardFocusManager().getCurrentSequencedEvent();
if (currentSE != null) {
if (log.isLoggable(PlatformLogger.Level.FINE)) {
log.fine("Dispose current SequencedEvent: " + currentSE);
}
currentSE.dispose();
}
// In case the exit() method is called before starting
// new event pump it will post the waking event to EDT.
// The event will be handled after the the new event pump
// starts. Thus, the enter() method will not hang.
//
// Event pump should be privileged. See 6300270.
AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
run.run();
return null;
}
});
} else {
if (log.isLoggable(PlatformLogger.Level.FINEST)) {
log.finest("On non-dispatch thread: " + currentThread);
}
synchronized (getTreeLock()) {
if (filter != null) {
dispatchThread.addEventFilter(filter);
}
try {
EventQueue eq = dispatchThread.getEventQueue();
eq.postEvent(new PeerEvent(this, run, PeerEvent.PRIORITY_EVENT));
keepBlockingCT.set(true);
if (interval > 0) {
long currTime = System.currentTimeMillis();
while (keepBlockingCT.get()
&& ((extCondition != null) ? extCondition.evaluate() : true)
&& (currTime + interval > System.currentTimeMillis())) {
getTreeLock().wait(interval);
}
} else {
while (keepBlockingCT.get()
&& ((extCondition != null) ? extCondition.evaluate() : true)) {
getTreeLock().wait();
}
}
if (log.isLoggable(PlatformLogger.Level.FINE)) {
log.fine("waitDone " + keepBlockingEDT.get() + " " + keepBlockingCT.get());
}
} catch (InterruptedException e) {
if (log.isLoggable(PlatformLogger.Level.FINE)) {
log.fine("Exception caught while waiting: " + e);
}
} finally {
if (filter != null) {
dispatchThread.removeEventFilter(filter);
}
}
// If the waiting process has been stopped because of the
// time interval passed or an exception occurred, the state
// should be changed
keepBlockingEDT.set(false);
keepBlockingCT.set(false);
}
}
return true;
}
/** @inheritDoc */
public boolean exit() {
if (log.isLoggable(PlatformLogger.Level.FINE)) {
log.fine(
"exit(): blockingEDT=" + keepBlockingEDT.get() + ", blockingCT=" + keepBlockingCT.get());
}
if (keepBlockingEDT.compareAndSet(true, false)) {
wakeupEDT();
return true;
}
return false;
}
private static final Object getTreeLock() {
return Component.LOCK;
}
private final Runnable wakingRunnable =
new Runnable() {
public void run() {
log.fine("Wake up EDT");
synchronized (getTreeLock()) {
keepBlockingCT.set(false);
getTreeLock().notifyAll();
}
log.fine("Wake up EDT done");
}
};
private void wakeupEDT() {
if (log.isLoggable(PlatformLogger.Level.FINEST)) {
log.finest("wakeupEDT(): EDT == " + dispatchThread);
}
EventQueue eq = dispatchThread.getEventQueue();
eq.postEvent(new PeerEvent(this, wakingRunnable, PeerEvent.PRIORITY_EVENT));
}
}
/**
* The XDragSourceContextPeer class is the class responsible for handling the interaction between
* the XDnD/Motif DnD subsystem and Java drag sources.
*
* @since 1.5
*/
public final class XDragSourceContextPeer extends SunDragSourceContextPeer
implements XDragSourceProtocolListener {
private static final PlatformLogger logger =
PlatformLogger.getLogger("sun.awt.X11.xembed.xdnd.XDragSourceContextPeer");
/* The events selected on the root window when the drag begins. */
private static final int ROOT_EVENT_MASK =
(int) XConstants.ButtonMotionMask
| (int) XConstants.KeyPressMask
| (int) XConstants.KeyReleaseMask;
/* The events to be delivered during grab. */
private static final int GRAB_EVENT_MASK =
(int) XConstants.ButtonPressMask
| (int) XConstants.ButtonMotionMask
| (int) XConstants.ButtonReleaseMask;
/* The event mask of the root window before the drag operation starts. */
private long rootEventMask = 0;
private boolean dndInProgress = false;
private boolean dragInProgress = false;
private long dragRootWindow = 0;
/* The protocol chosen for the communication with the current drop target. */
private XDragSourceProtocol dragProtocol = null;
/* The drop action chosen by the current drop target. */
private int targetAction = DnDConstants.ACTION_NONE;
/* The set of drop actions supported by the drag source. */
private int sourceActions = DnDConstants.ACTION_NONE;
/* The drop action selected by the drag source based on the modifiers state
and the action selected by the current drop target. */
private int sourceAction = DnDConstants.ACTION_NONE;
/* The data formats supported by the drag source for the current drag
operation. */
private long[] sourceFormats = null;
/* The XID of the root subwindow that contains the current target. */
private long targetRootSubwindow = 0;
/* The pointer location. */
private int xRoot = 0;
private int yRoot = 0;
/* Keyboard modifiers state. */
private int eventState = 0;
/* XEmbed DnD support. We act as a proxy between source and target. */
private long proxyModeSourceWindow = 0;
/* The singleton instance. */
private static final XDragSourceContextPeer theInstance = new XDragSourceContextPeer(null);
private XDragSourceContextPeer(DragGestureEvent dge) {
super(dge);
}
static XDragSourceProtocolListener getXDragSourceProtocolListener() {
return theInstance;
}
static XDragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge)
throws InvalidDnDOperationException {
theInstance.setTrigger(dge);
return theInstance;
}
protected void startDrag(Transferable transferable, long[] formats, Map formatMap) {
Component component = getTrigger().getComponent();
Component c = null;
XWindowPeer wpeer = null;
for (c = component;
c != null && !(c instanceof Window);
c = AWTAccessor.getComponentAccessor().getParent(c)) ;
if (c instanceof Window) {
wpeer = (XWindowPeer) c.getPeer();
}
if (wpeer == null) {
throw new InvalidDnDOperationException("Cannot find top-level for the drag source component");
}
long xcursor = 0;
long rootWindow = 0;
long dragWindow = 0;
long timeStamp = 0;
/* Retrieve the X cursor for the drag operation. */
{
Cursor cursor = getCursor();
if (cursor != null) {
xcursor = XGlobalCursorManager.getCursor(cursor);
}
}
XToolkit.awtLock();
try {
if (proxyModeSourceWindow != 0) {
throw new InvalidDnDOperationException("Proxy drag in progress");
}
if (dndInProgress) {
throw new InvalidDnDOperationException("Drag in progress");
}
/* Determine the root window for the drag operation. */
{
long screen = XlibWrapper.XScreenNumberOfScreen(wpeer.getScreen());
rootWindow = XlibWrapper.RootWindow(XToolkit.getDisplay(), screen);
}
dragWindow = XWindow.getXAWTRootWindow().getWindow();
timeStamp = XToolkit.getCurrentServerTime();
int dropActions = getDragSourceContext().getSourceActions();
Iterator dragProtocols = XDragAndDropProtocols.getDragSourceProtocols();
while (dragProtocols.hasNext()) {
XDragSourceProtocol dragProtocol = (XDragSourceProtocol) dragProtocols.next();
try {
dragProtocol.initializeDrag(
dropActions, transferable,
formatMap, formats);
} catch (XException xe) {
throw (InvalidDnDOperationException) new InvalidDnDOperationException().initCause(xe);
}
}
/* Install X grabs. */
{
int status;
XWindowAttributes wattr = new XWindowAttributes();
try {
status = XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(), rootWindow, wattr.pData);
if (status == 0) {
throw new InvalidDnDOperationException("XGetWindowAttributes failed");
}
rootEventMask = wattr.get_your_event_mask();
XlibWrapper.XSelectInput(
XToolkit.getDisplay(), rootWindow, rootEventMask | ROOT_EVENT_MASK);
} finally {
wattr.dispose();
}
XBaseWindow.ungrabInput();
status =
XlibWrapper.XGrabPointer(
XToolkit.getDisplay(),
rootWindow,
0,
GRAB_EVENT_MASK,
XConstants.GrabModeAsync,
XConstants.GrabModeAsync,
XConstants.None,
xcursor,
timeStamp);
if (status != XConstants.GrabSuccess) {
cleanup(timeStamp);
throwGrabFailureException("Cannot grab pointer", status);
return;
}
status =
XlibWrapper.XGrabKeyboard(
XToolkit.getDisplay(),
rootWindow,
0,
XConstants.GrabModeAsync,
XConstants.GrabModeAsync,
timeStamp);
if (status != XConstants.GrabSuccess) {
cleanup(timeStamp);
throwGrabFailureException("Cannot grab keyboard", status);
return;
}
}
/* Update the global state. */
dndInProgress = true;
dragInProgress = true;
dragRootWindow = rootWindow;
sourceActions = dropActions;
sourceFormats = formats;
} finally {
XToolkit.awtUnlock();
}
/* This implementation doesn't use native context */
setNativeContext(0);
SunDropTargetContextPeer.setCurrentJVMLocalSourceTransferable(transferable);
}
public long getProxyModeSourceWindow() {
return proxyModeSourceWindow;
}
private void setProxyModeSourceWindowImpl(long window) {
proxyModeSourceWindow = window;
}
public static void setProxyModeSourceWindow(long window) {
theInstance.setProxyModeSourceWindowImpl(window);
}
/** set cursor */
public void setCursor(Cursor c) throws InvalidDnDOperationException {
XToolkit.awtLock();
try {
super.setCursor(c);
} finally {
XToolkit.awtUnlock();
}
}
protected void setNativeCursor(long nativeCtxt, Cursor c, int cType) {
assert XToolkit.isAWTLockHeldByCurrentThread();
if (c == null) {
return;
}
long xcursor = XGlobalCursorManager.getCursor(c);
if (xcursor == 0) {
return;
}
XlibWrapper.XChangeActivePointerGrab(
XToolkit.getDisplay(), GRAB_EVENT_MASK, xcursor, XConstants.CurrentTime);
}
protected boolean needsBogusExitBeforeDrop() {
return false;
}
private void throwGrabFailureException(String msg, int grabStatus)
throws InvalidDnDOperationException {
String msgCause = "";
switch (grabStatus) {
case XConstants.GrabNotViewable:
msgCause = "not viewable";
break;
case XConstants.AlreadyGrabbed:
msgCause = "already grabbed";
break;
case XConstants.GrabInvalidTime:
msgCause = "invalid time";
break;
case XConstants.GrabFrozen:
msgCause = "grab frozen";
break;
default:
msgCause = "unknown failure";
break;
}
throw new InvalidDnDOperationException(msg + ": " + msgCause);
}
/** The caller must own awtLock. */
public void cleanup(long time) {
if (dndInProgress) {
if (dragProtocol != null) {
dragProtocol.sendLeaveMessage(time);
}
if (targetAction != DnDConstants.ACTION_NONE) {
dragExit(xRoot, yRoot);
}
dragDropFinished(false, DnDConstants.ACTION_NONE, xRoot, yRoot);
}
Iterator dragProtocols = XDragAndDropProtocols.getDragSourceProtocols();
while (dragProtocols.hasNext()) {
XDragSourceProtocol dragProtocol = (XDragSourceProtocol) dragProtocols.next();
try {
dragProtocol.cleanup();
} catch (XException xe) {
// Ignore the exception.
}
}
dndInProgress = false;
dragInProgress = false;
dragRootWindow = 0;
sourceFormats = null;
sourceActions = DnDConstants.ACTION_NONE;
sourceAction = DnDConstants.ACTION_NONE;
eventState = 0;
xRoot = 0;
yRoot = 0;
cleanupTargetInfo();
removeDnDGrab(time);
}
/** The caller must own awtLock. */
private void cleanupTargetInfo() {
targetAction = DnDConstants.ACTION_NONE;
dragProtocol = null;
targetRootSubwindow = 0;
}
private void removeDnDGrab(long time) {
assert XToolkit.isAWTLockHeldByCurrentThread();
XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), time);
XlibWrapper.XUngrabKeyboard(XToolkit.getDisplay(), time);
/* Restore the root event mask if it was changed. */
if ((rootEventMask | ROOT_EVENT_MASK) != rootEventMask && dragRootWindow != 0) {
XlibWrapper.XSelectInput(XToolkit.getDisplay(), dragRootWindow, rootEventMask);
}
rootEventMask = 0;
dragRootWindow = 0;
}
private boolean processClientMessage(XClientMessageEvent xclient) {
if (dragProtocol != null) {
return dragProtocol.processClientMessage(xclient);
}
return false;
}
/**
* Updates the source action according to the specified state.
*
* @returns true if the source
*/
private boolean updateSourceAction(int state) {
int action =
SunDragSourceContextPeer.convertModifiersToDropAction(
XWindow.getModifiers(state, 0, 0), sourceActions);
if (sourceAction == action) {
return false;
}
sourceAction = action;
return true;
}
/** Returns the client window under the specified root subwindow. */
private static long findClientWindow(long window) {
if (XlibUtil.isTrueToplevelWindow(window)) {
return window;
}
Set<Long> children = XlibUtil.getChildWindows(window);
for (Long child : children) {
long win = findClientWindow(child);
if (win != 0) {
return win;
}
}
return 0;
}
private void doUpdateTargetWindow(long subwindow, long time) {
long clientWindow = 0;
long proxyWindow = 0;
XDragSourceProtocol protocol = null;
boolean isReceiver = false;
if (subwindow != 0) {
clientWindow = findClientWindow(subwindow);
}
if (clientWindow != 0) {
Iterator dragProtocols = XDragAndDropProtocols.getDragSourceProtocols();
while (dragProtocols.hasNext()) {
XDragSourceProtocol dragProtocol = (XDragSourceProtocol) dragProtocols.next();
if (dragProtocol.attachTargetWindow(clientWindow, time)) {
protocol = dragProtocol;
break;
}
}
}
/* Update the global state. */
dragProtocol = protocol;
targetAction = DnDConstants.ACTION_NONE;
targetRootSubwindow = subwindow;
}
private void updateTargetWindow(XMotionEvent xmotion) {
assert XToolkit.isAWTLockHeldByCurrentThread();
int x = xmotion.get_x_root();
int y = xmotion.get_y_root();
long time = xmotion.get_time();
long subwindow = xmotion.get_subwindow();
/*
* If this event had occurred before the pointer was grabbed,
* query the server for the current root subwindow.
*/
if (xmotion.get_window() != xmotion.get_root()) {
XlibWrapper.XQueryPointer(
XToolkit.getDisplay(),
xmotion.get_root(),
XlibWrapper.larg1, // root
XlibWrapper.larg2, // subwindow
XlibWrapper.larg3, // x_root
XlibWrapper.larg4, // y_root
XlibWrapper.larg5, // x
XlibWrapper.larg6, // y
XlibWrapper.larg7); // modifiers
subwindow = Native.getLong(XlibWrapper.larg2);
}
if (targetRootSubwindow != subwindow) {
if (dragProtocol != null) {
dragProtocol.sendLeaveMessage(time);
/*
* Neither Motif DnD nor XDnD provide a mean for the target
* to notify the source that the pointer exits the drop site
* that occupies the whole top level.
* We detect this situation and post dragExit.
*/
if (targetAction != DnDConstants.ACTION_NONE) {
dragExit(x, y);
}
}
/* Update the global state. */
doUpdateTargetWindow(subwindow, time);
if (dragProtocol != null) {
dragProtocol.sendEnterMessage(sourceFormats, sourceAction, sourceActions, time);
}
}
}
/*
* DO NOT USE is_hint field of xmotion since it could not be set when we
* convert XKeyEvent or XButtonRelease to XMotionEvent.
*/
private void processMouseMove(XMotionEvent xmotion) {
if (!dragInProgress) {
return;
}
if (xRoot != xmotion.get_x_root() || yRoot != xmotion.get_y_root()) {
xRoot = xmotion.get_x_root();
yRoot = xmotion.get_y_root();
postDragSourceDragEvent(
targetAction,
XWindow.getModifiers(xmotion.get_state(), 0, 0),
xRoot,
yRoot,
DISPATCH_MOUSE_MOVED);
}
if (eventState != xmotion.get_state()) {
if (updateSourceAction(xmotion.get_state()) && dragProtocol != null) {
postDragSourceDragEvent(
targetAction,
XWindow.getModifiers(xmotion.get_state(), 0, 0),
xRoot,
yRoot,
DISPATCH_CHANGED);
}
eventState = xmotion.get_state();
}
updateTargetWindow(xmotion);
if (dragProtocol != null) {
dragProtocol.sendMoveMessage(
xmotion.get_x_root(),
xmotion.get_y_root(),
sourceAction,
sourceActions,
xmotion.get_time());
}
}
private void processDrop(XButtonEvent xbutton) {
try {
dragProtocol.initiateDrop(
xbutton.get_x_root(),
xbutton.get_y_root(),
sourceAction,
sourceActions,
xbutton.get_time());
} catch (XException e) {
cleanup(xbutton.get_time());
}
}
private boolean processProxyModeEvent(XEvent ev) {
if (getProxyModeSourceWindow() == 0) {
return false;
}
if (ev.get_type() != (int) XConstants.ClientMessage) {
return false;
}
if (logger.isLoggable(PlatformLogger.Level.FINEST)) {
logger.finest(" proxyModeSourceWindow=" + getProxyModeSourceWindow() + " ev=" + ev);
}
XClientMessageEvent xclient = ev.get_xclient();
Iterator dragProtocols = XDragAndDropProtocols.getDragSourceProtocols();
while (dragProtocols.hasNext()) {
XDragSourceProtocol dragProtocol = (XDragSourceProtocol) dragProtocols.next();
if (dragProtocol.processProxyModeEvent(xclient, getProxyModeSourceWindow())) {
return true;
}
}
return false;
}
/**
* The caller must own awtLock.
*
* @returns true if the even was processed and shouldn't be passed along.
*/
private boolean doProcessEvent(XEvent ev) {
assert XToolkit.isAWTLockHeldByCurrentThread();
if (processProxyModeEvent(ev)) {
return true;
}
if (!dndInProgress) {
return false;
}
switch (ev.get_type()) {
case XConstants.ClientMessage:
{
XClientMessageEvent xclient = ev.get_xclient();
return processClientMessage(xclient);
}
case XConstants.DestroyNotify:
{
XDestroyWindowEvent xde = ev.get_xdestroywindow();
/* Target crashed during drop processing - cleanup. */
if (!dragInProgress
&& dragProtocol != null
&& xde.get_window() == dragProtocol.getTargetWindow()) {
cleanup(XConstants.CurrentTime);
return true;
}
/* Pass along */
return false;
}
}
if (!dragInProgress) {
return false;
}
/* Process drag-only messages. */
switch (ev.get_type()) {
case XConstants.KeyRelease:
case XConstants.KeyPress:
{
XKeyEvent xkey = ev.get_xkey();
long keysym = XlibWrapper.XKeycodeToKeysym(XToolkit.getDisplay(), xkey.get_keycode(), 0);
switch ((int) keysym) {
case (int) XKeySymConstants.XK_Escape:
{
if (ev.get_type() == (int) XConstants.KeyRelease) {
cleanup(xkey.get_time());
}
break;
}
case (int) XKeySymConstants.XK_Control_R:
case (int) XKeySymConstants.XK_Control_L:
case (int) XKeySymConstants.XK_Shift_R:
case (int) XKeySymConstants.XK_Shift_L:
{
XlibWrapper.XQueryPointer(
XToolkit.getDisplay(),
xkey.get_root(),
XlibWrapper.larg1, // root
XlibWrapper.larg2, // subwindow
XlibWrapper.larg3, // x_root
XlibWrapper.larg4, // y_root
XlibWrapper.larg5, // x
XlibWrapper.larg6, // y
XlibWrapper.larg7); // modifiers
XMotionEvent xmotion = new XMotionEvent();
try {
xmotion.set_type(XConstants.MotionNotify);
xmotion.set_serial(xkey.get_serial());
xmotion.set_send_event(xkey.get_send_event());
xmotion.set_display(xkey.get_display());
xmotion.set_window(xkey.get_window());
xmotion.set_root(xkey.get_root());
xmotion.set_subwindow(xkey.get_subwindow());
xmotion.set_time(xkey.get_time());
xmotion.set_x(xkey.get_x());
xmotion.set_y(xkey.get_y());
xmotion.set_x_root(xkey.get_x_root());
xmotion.set_y_root(xkey.get_y_root());
xmotion.set_state((int) Native.getLong(XlibWrapper.larg7));
// we do not use this field, so it's unset for now
// xmotion.set_is_hint(???);
xmotion.set_same_screen(xkey.get_same_screen());
// It's safe to use key event as motion event since we use only their common
// fields.
processMouseMove(xmotion);
} finally {
xmotion.dispose();
}
break;
}
}
return true;
}
case XConstants.ButtonPress:
return true;
case XConstants.MotionNotify:
processMouseMove(ev.get_xmotion());
return true;
case XConstants.ButtonRelease:
{
XButtonEvent xbutton = ev.get_xbutton();
/*
* Ignore the buttons above 20 due to the bit limit for
* InputEvent.BUTTON_DOWN_MASK.
* One more bit is reserved for FIRST_HIGH_BIT.
*/
if (xbutton.get_button() > SunToolkit.MAX_BUTTONS_SUPPORTED) {
return true;
}
/*
* On some X servers it could happen that ButtonRelease coordinates
* differ from the latest MotionNotify coordinates, so we need to
* process it as a mouse motion.
*/
XMotionEvent xmotion = new XMotionEvent();
try {
xmotion.set_type(XConstants.MotionNotify);
xmotion.set_serial(xbutton.get_serial());
xmotion.set_send_event(xbutton.get_send_event());
xmotion.set_display(xbutton.get_display());
xmotion.set_window(xbutton.get_window());
xmotion.set_root(xbutton.get_root());
xmotion.set_subwindow(xbutton.get_subwindow());
xmotion.set_time(xbutton.get_time());
xmotion.set_x(xbutton.get_x());
xmotion.set_y(xbutton.get_y());
xmotion.set_x_root(xbutton.get_x_root());
xmotion.set_y_root(xbutton.get_y_root());
xmotion.set_state(xbutton.get_state());
// we do not use this field, so it's unset for now
// xmotion.set_is_hint(???);
xmotion.set_same_screen(xbutton.get_same_screen());
// It's safe to use key event as motion event since we use only their common fields.
processMouseMove(xmotion);
} finally {
xmotion.dispose();
}
if (xbutton.get_button() == XConstants.buttons[0]
|| xbutton.get_button() == XConstants.buttons[1]) {
// drag is initiated with Button1 or Button2 pressed and
// ended on release of either of these buttons (as the same
// behavior was with our old Motif DnD-based implementation)
removeDnDGrab(xbutton.get_time());
dragInProgress = false;
if (dragProtocol != null && targetAction != DnDConstants.ACTION_NONE) {
/*
* ACTION_NONE indicates that either the drop target rejects the
* drop or it haven't responded yet. The latter could happen in
* case of fast drag, slow target-server connection or slow
* drag notifications processing on the target side.
*/
processDrop(xbutton);
} else {
cleanup(xbutton.get_time());
}
}
return true;
}
}
return false;
}
static boolean processEvent(XEvent ev) {
XToolkit.awtLock();
try {
try {
return theInstance.doProcessEvent(ev);
} catch (XException e) {
e.printStackTrace();
return false;
}
} finally {
XToolkit.awtUnlock();
}
}
/* XDragSourceProtocolListener implementation */
public void handleDragReply(int action) {
// NOTE: we have to use the current pointer location, since
// the target didn't specify the coordinates for the reply.
handleDragReply(action, xRoot, yRoot);
}
public void handleDragReply(int action, int x, int y) {
// NOTE: we have to use the current modifiers state, since
// the target didn't specify the modifiers state for the reply.
handleDragReply(action, xRoot, yRoot, XWindow.getModifiers(eventState, 0, 0));
}
public void handleDragReply(int action, int x, int y, int modifiers) {
if (action == DnDConstants.ACTION_NONE && targetAction != DnDConstants.ACTION_NONE) {
dragExit(x, y);
} else if (action != DnDConstants.ACTION_NONE) {
int type = 0;
if (targetAction == DnDConstants.ACTION_NONE) {
type = SunDragSourceContextPeer.DISPATCH_ENTER;
} else {
type = SunDragSourceContextPeer.DISPATCH_MOTION;
}
// Note that we use the modifiers state a
postDragSourceDragEvent(action, modifiers, x, y, type);
}
targetAction = action;
}
public void handleDragFinished() {
/* Assume that the drop was successful. */
handleDragFinished(true);
}
public void handleDragFinished(boolean success) {
/* Assume that the performed drop action is the latest drop action
accepted by the drop target. */
handleDragFinished(true, targetAction);
}
public void handleDragFinished(boolean success, int action) {
// NOTE: we have to use the current pointer location, since
// the target didn't specify the coordinates for the reply.
handleDragFinished(success, action, xRoot, yRoot);
}
public void handleDragFinished(boolean success, int action, int x, int y) {
dragDropFinished(success, action, x, y);
dndInProgress = false;
cleanup(XConstants.CurrentTime);
}
}