/**
* Called after window creation, descendants should override to initialize Window with
* class-specific values and perform post-initialization actions.
*/
void postInit(XCreateWindowParams params) {
if (log.isLoggable(Level.FINE)) log.fine("WM name is " + getWMName());
updateWMName();
// Set WM_CLIENT_LEADER property
initClientLeader();
}
public void dispatchEvent(XEvent xev) {
if (eventLog.isLoggable(Level.FINEST)) eventLog.finest(xev.toString());
int type = xev.get_type();
if (isDisposed()) {
return;
}
switch (type) {
case VisibilityNotify:
handleVisibilityEvent(xev);
break;
case ClientMessage:
handleClientMessage(xev);
break;
case Expose:
case GraphicsExpose:
handleExposeEvent(xev);
break;
case ButtonPress:
case ButtonRelease:
handleButtonPressRelease(xev);
break;
case MotionNotify:
handleMotionNotify(xev);
break;
case KeyPress:
handleKeyPress(xev);
break;
case KeyRelease:
handleKeyRelease(xev);
break;
case EnterNotify:
case LeaveNotify:
handleXCrossingEvent(xev);
break;
case ConfigureNotify:
handleConfigureNotifyEvent(xev);
break;
case MapNotify:
handleMapNotifyEvent(xev);
break;
case UnmapNotify:
handleUnmapNotifyEvent(xev);
break;
case ReparentNotify:
handleReparentNotifyEvent(xev);
break;
case PropertyNotify:
handlePropertyNotify(xev);
break;
case DestroyNotify:
handleDestroyNotify(xev);
break;
case CreateNotify:
handleCreateNotify(xev);
break;
}
}
public void handlePropertyNotify(XEvent xev) {
XPropertyEvent msg = xev.get_xproperty();
if (XPropertyCache.isCachingSupported()) {
XPropertyCache.clearCache(window, XAtom.get(msg.get_atom()));
}
if (eventLog.isLoggable(Level.FINER)) {
eventLog.log(Level.FINER, "{0}", new Object[] {String.valueOf(msg)});
}
}
public void xRequestFocus() {
XToolkit.awtLock();
try {
if (focusLog.isLoggable(Level.FINER))
focusLog.finer("XSetInputFocus on " + Long.toHexString(getWindow()));
XlibWrapper.XSetInputFocus(XToolkit.getDisplay(), getWindow());
} finally {
XToolkit.awtUnlock();
}
}
public void handleConfigureNotifyEvent(XEvent xev) {
XConfigureEvent xe = xev.get_xconfigure();
if (insLog.isLoggable(Level.FINER)) {
insLog.log(Level.FINER, "Configure, {0}", new Object[] {String.valueOf(xe)});
}
x = xe.get_x();
y = xe.get_y();
width = xe.get_width();
height = xe.get_height();
}
public void setValueIn(final Component comp) {
// SwingUtilities.invokeAndWait(new Runnable() {
// public void run() {
JToggleButton fl = (JToggleButton) comp;
if (log.isLoggable(Level.INFO)) {
log.info("pref:" + pref + ", def=" + def + ", val=" + pr.getBoolean(pref, def));
}
fl.setSelected(pr.getBoolean(pref, def));
// }
// });
}
/**
* Returns the current stream connection that is opened.
*
* @return a stream connection, can be a cached one, never <code>null</code>.
* @throws IOException in case of I/O problems creating the stream connection.
*/
private StreamConnection getStreamConnection() throws IOException {
if (this.connection == null) {
final String uri = this.config.getConnectionURI();
if (LOG.isLoggable(Level.INFO)) {
LOG.info("Connecting to " + uri);
}
this.connection = createStreamConnection(uri);
}
return this.connection;
}
public void xSetVisible(boolean visible) {
if (log.isLoggable(Level.FINE)) log.fine("Setting visible on " + this + " to " + visible);
XToolkit.awtLock();
try {
this.visible = visible;
if (visible) {
XlibWrapper.XMapWindow(XToolkit.getDisplay(), getWindow());
} else {
XlibWrapper.XUnmapWindow(XToolkit.getDisplay(), getWindow());
}
XlibWrapper.XFlush(XToolkit.getDisplay());
} finally {
XToolkit.awtUnlock();
}
}
/**
* Sets the current device controller to the given value.
*
* @param aDeviceName the name of the device controller to set, cannot be <code>null</code>.
*/
public synchronized void setDeviceController(final String aDeviceName) {
if (LOG.isLoggable(Level.INFO)) {
final String name = (aDeviceName == null) ? "no device" : aDeviceName;
LOG.log(Level.INFO, "Setting current device controller to: \"{0}\" ...", name);
}
final Collection<DeviceController> devices = getDevices();
for (DeviceController device : devices) {
if (aDeviceName.equals(device.getName())) {
this.currentDevCtrl = device;
}
}
updateActions();
}
/**
* Runs the tool denoted by the given name.
*
* @param aToolName the name of the tool to run, cannot be <code>null</code>;
* @param aParent the parent window to use, can be <code>null</code>.
*/
public void runTool(final String aToolName, final Window aParent) {
if (LOG.isLoggable(Level.INFO)) {
LOG.log(Level.INFO, "Running tool: \"{0}\" ...", aToolName);
}
final Tool tool = findToolByName(aToolName);
if (tool == null) {
JOptionPane.showMessageDialog(
aParent, "No such tool found: " + aToolName, "Error ...", JOptionPane.ERROR_MESSAGE);
} else {
final ToolContext context = createToolContext();
tool.process(aParent, this.dataContainer, context, this);
}
updateActions();
}
static void ungrabInput() {
XToolkit.awtLock();
try {
XBaseWindow grabWindow = XAwtState.getGrabWindow();
if (grabLog.isLoggable(Level.FINE)) {
grabLog.log(Level.FINE, "UnGrab input on {0}", new Object[] {String.valueOf(grabWindow)});
}
if (grabWindow != null) {
grabWindow.ungrabInputImpl();
XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), CurrentTime);
XlibWrapper.XUngrabKeyboard(XToolkit.getDisplay(), CurrentTime);
XAwtState.setGrabWindow(null);
// we need to call XFlush() here to force ungrab
// see 6384219 for details
XlibWrapper.XFlush(XToolkit.getDisplay());
}
} finally {
XToolkit.awtUnlock();
}
}
public void handleClientMessage(XEvent xev) {
if (eventLog.isLoggable(Level.FINER)) {
XClientMessageEvent msg = xev.get_xclient();
eventLog.finer(msg.toString());
}
}
public void handleReparentNotifyEvent(XEvent xev) {
if (eventLog.isLoggable(Level.FINER)) {
XReparentEvent msg = xev.get_xreparent();
eventLog.finer(msg.toString());
}
}
/**
* We should always grab both keyboard and pointer to control event flow on popups. This also
* simplifies synthetic grab implementation. The active grab overrides activated automatic grab.
*/
public boolean grabInput() {
if (grabLog.isLoggable(Level.FINE)) {
grabLog.log(Level.FINE, "Grab input on {0}", new Object[] {String.valueOf(this)});
}
XToolkit.awtLock();
try {
if (XAwtState.getGrabWindow() == this && XAwtState.isManualGrab()) {
grabLog.fine(" Already Grabbed");
return true;
}
// 6273031: PIT. Choice drop down does not close once it is right clicked to show a popup menu
// remember previous window having grab and if it's not null ungrab it.
XBaseWindow prevGrabWindow = XAwtState.getGrabWindow();
final int eventMask =
(int)
(ButtonPressMask
| ButtonReleaseMask
| EnterWindowMask
| LeaveWindowMask
| PointerMotionMask
| ButtonMotionMask);
final int ownerEvents = 1;
int ptrGrab =
XlibWrapper.XGrabPointer(
XToolkit.getDisplay(),
getContentWindow(),
ownerEvents,
eventMask,
GrabModeAsync,
GrabModeAsync,
None,
(XWM.isMotif() ? XToolkit.arrowCursor : None),
CurrentTime);
// Check grab results to be consistent with X server grab
if (ptrGrab != GrabSuccess) {
XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), CurrentTime);
XAwtState.setGrabWindow(null);
grabLog.fine(" Grab Failure - mouse");
return false;
}
int keyGrab =
XlibWrapper.XGrabKeyboard(
XToolkit.getDisplay(),
getContentWindow(),
ownerEvents,
GrabModeAsync,
GrabModeAsync,
CurrentTime);
if (keyGrab != GrabSuccess) {
XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), CurrentTime);
XlibWrapper.XUngrabKeyboard(XToolkit.getDisplay(), CurrentTime);
XAwtState.setGrabWindow(null);
grabLog.fine(" Grab Failure - keyboard");
return false;
}
if (prevGrabWindow != null) {
prevGrabWindow.ungrabInputImpl();
}
XAwtState.setGrabWindow(this);
grabLog.fine(" Grab - success");
return true;
} finally {
XToolkit.awtUnlock();
}
}
public void setSizeHints(long flags, int x, int y, int width, int height) {
if (insLog.isLoggable(Level.FINER))
insLog.finer("Setting hints, flags " + XlibWrapper.hintsToString(flags));
XToolkit.awtLock();
try {
XSizeHints hints = getHints();
// Note: if PPosition is not set in flags this means that
// we want to reset PPosition in hints. This is necessary
// for locationByPlatform functionality
if ((flags & XlibWrapper.PPosition) != 0) {
hints.set_x(x);
hints.set_y(y);
}
if ((flags & XlibWrapper.PSize) != 0) {
hints.set_width(width);
hints.set_height(height);
} else if ((hints.get_flags() & XlibWrapper.PSize) != 0) {
flags |= XlibWrapper.PSize;
}
if ((flags & XlibWrapper.PMinSize) != 0) {
hints.set_min_width(width);
hints.set_min_height(height);
} else if ((hints.get_flags() & XlibWrapper.PMinSize) != 0) {
flags |= XlibWrapper.PMinSize;
// Fix for 4320050: Minimum size for java.awt.Frame is not being enforced.
// We don't need to reset minimum size if it's already set
}
if ((flags & XlibWrapper.PMaxSize) != 0) {
if (maxBounds != null) {
if (maxBounds.width != Integer.MAX_VALUE) {
hints.set_max_width(maxBounds.width);
} else {
hints.set_max_width(XToolkit.getDefaultScreenWidth());
}
if (maxBounds.height != Integer.MAX_VALUE) {
hints.set_max_height(maxBounds.height);
} else {
hints.set_max_height(XToolkit.getDefaultScreenHeight());
}
} else {
hints.set_max_width(width);
hints.set_max_height(height);
}
} else if ((hints.get_flags() & XlibWrapper.PMaxSize) != 0) {
flags |= XlibWrapper.PMaxSize;
if (maxBounds != null) {
if (maxBounds.width != Integer.MAX_VALUE) {
hints.set_max_width(maxBounds.width);
} else {
hints.set_max_width(XToolkit.getDefaultScreenWidth());
}
if (maxBounds.height != Integer.MAX_VALUE) {
hints.set_max_height(maxBounds.height);
} else {
hints.set_max_height(XToolkit.getDefaultScreenHeight());
}
} else {
// Leave intact
}
}
flags |= XlibWrapper.PWinGravity;
hints.set_flags(flags);
hints.set_win_gravity((int) XlibWrapper.NorthWestGravity);
if (insLog.isLoggable(Level.FINER))
insLog.finer(
"Setting hints, resulted flags "
+ XlibWrapper.hintsToString(flags)
+ ", values "
+ hints);
XlibWrapper.XSetWMNormalHints(XToolkit.getDisplay(), getWindow(), hints.pData);
} finally {
XToolkit.awtUnlock();
}
}
/**
* Creates window with parameters specified by <code>params</code>
*
* @see #init
*/
private final void create(XCreateWindowParams params) {
XToolkit.awtLock();
try {
XSetWindowAttributes xattr = new XSetWindowAttributes();
try {
checkParams(params);
long value_mask = ((Long) params.get(VALUE_MASK)).longValue();
Long eventMask = (Long) params.get(EVENT_MASK);
xattr.set_event_mask(eventMask.longValue());
value_mask |= XlibWrapper.CWEventMask;
Long border_pixel = (Long) params.get(BORDER_PIXEL);
if (border_pixel != null) {
xattr.set_border_pixel(border_pixel.longValue());
value_mask |= XlibWrapper.CWBorderPixel;
}
Long colormap = (Long) params.get(COLORMAP);
if (colormap != null) {
xattr.set_colormap(colormap.longValue());
value_mask |= XlibWrapper.CWColormap;
}
Long background_pixmap = (Long) params.get(BACKGROUND_PIXMAP);
if (background_pixmap != null) {
xattr.set_background_pixmap(background_pixmap.longValue());
value_mask |= XlibWrapper.CWBackPixmap;
}
Long parentWindow = (Long) params.get(PARENT_WINDOW);
Rectangle bounds = (Rectangle) params.get(BOUNDS);
Integer depth = (Integer) params.get(DEPTH);
Integer visual_class = (Integer) params.get(VISUAL_CLASS);
Long visual = (Long) params.get(VISUAL);
Boolean overrideRedirect = (Boolean) params.get(OVERRIDE_REDIRECT);
if (overrideRedirect != null) {
xattr.set_override_redirect(overrideRedirect.booleanValue());
value_mask |= XlibWrapper.CWOverrideRedirect;
}
Boolean saveUnder = (Boolean) params.get(SAVE_UNDER);
if (saveUnder != null) {
xattr.set_save_under(saveUnder.booleanValue());
value_mask |= XlibWrapper.CWSaveUnder;
}
Integer backingStore = (Integer) params.get(BACKING_STORE);
if (backingStore != null) {
xattr.set_backing_store(backingStore.intValue());
value_mask |= XlibWrapper.CWBackingStore;
}
Integer bitGravity = (Integer) params.get(BIT_GRAVITY);
if (bitGravity != null) {
xattr.set_bit_gravity(bitGravity.intValue());
value_mask |= XlibWrapper.CWBitGravity;
}
if (log.isLoggable(Level.FINE)) {
log.fine("Creating window for " + this + " with the following attributes: \n" + params);
}
window =
XlibWrapper.XCreateWindow(
XToolkit.getDisplay(),
parentWindow.longValue(),
bounds.x,
bounds.y, // location
bounds.width,
bounds.height, // size
0, // border
depth.intValue(), // depth
visual_class.intValue(), // class
visual.longValue(), // visual
value_mask, // value mask
xattr.pData); // attributes
if (window == 0) {
throw new IllegalStateException(
"Couldn't create window because of wrong parameters. Run with NOISY_AWT to see details");
}
XToolkit.addToWinMap(window, this);
} finally {
xattr.dispose();
}
} finally {
XToolkit.awtUnlock();
}
}