// 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(); }
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(); } }
/** Returns the parent for the given window */ static long getParentWindow(long window) { XToolkit.awtLock(); try { XBaseWindow bw = XToolkit.windowToXWindow(window); if (bw != null) { XBaseWindow pbw = bw.getParentWindow(); if (pbw != null) { return pbw.getWindow(); } } XQueryTree qt = new XQueryTree(window); try { if (qt.execute() == 0) { return 0; } else { return qt.get_parent(); } } finally { qt.dispose(); } } finally { XToolkit.awtUnlock(); } }
/** Returns the supported cursor size */ static Dimension getBestCursorSize(int preferredWidth, int preferredHeight) { // Fix for bug 4212593 The Toolkit.createCustomCursor does not // check absence of the image of cursor // We use XQueryBestCursor which accepts unsigned ints to obtain // the largest cursor size that could be dislpayed // Dimension d = new Dimension(Math.abs(preferredWidth), Math.abs(preferredHeight)); Dimension d; XToolkit.awtLock(); try { long display = XToolkit.getDisplay(); long root_window = XlibWrapper.RootWindow(display, XlibWrapper.DefaultScreen(display)); XlibWrapper.XQueryBestCursor( display, root_window, Math.abs(preferredWidth), Math.abs(preferredHeight), XlibWrapper.larg1, XlibWrapper.larg2); d = new Dimension( XlibWrapper.unsafe.getInt(XlibWrapper.larg1), XlibWrapper.unsafe.getInt(XlibWrapper.larg2)); } finally { XToolkit.awtUnlock(); } return d; }
/* */ public void addNotify() /* */ { /* 65 */ if (getPeer() == null) { /* 66 */ XToolkit localXToolkit = (XToolkit) Toolkit.getDefaultToolkit(); /* 67 */ setPeer(localXToolkit.createEmbeddedFrame(this)); /* */ } /* 69 */ super.addNotify(); /* */ }
/** Returns the bounds of the given window, in absolute coordinates */ static Rectangle getWindowGeometry(long window) { XToolkit.awtLock(); try { int res = XlibWrapper.XGetGeometry( XToolkit.getDisplay(), window, XlibWrapper.larg1, // root_return XlibWrapper.larg2, // x_return XlibWrapper.larg3, // y_return XlibWrapper.larg4, // width_return XlibWrapper.larg5, // height_return XlibWrapper.larg6, // border_width_return XlibWrapper.larg7); // depth_return if (res == 0) { return null; } int x = Native.getInt(XlibWrapper.larg2); int y = Native.getInt(XlibWrapper.larg3); long width = Native.getUInt(XlibWrapper.larg4); long height = Native.getUInt(XlibWrapper.larg5); return new Rectangle(x, y, (int) width, (int) height); } finally { XToolkit.awtUnlock(); } }
/** * Translate coordinates from one window into another. Optimized for XAWT - uses cached data when * possible. Preferable over pure XTranslateCoordinates. * * @return coordinates relative to dst, or null if error happened */ static Point toOtherWindow(long src, long dst, int x, int y) { Point rpt = new Point(0, 0); // Check if both windows belong to XAWT - then no X calls are necessary XBaseWindow srcPeer = XToolkit.windowToXWindow(src); XBaseWindow dstPeer = XToolkit.windowToXWindow(dst); if (srcPeer != null && dstPeer != null) { // (x, y) is relative to src rpt.x = x + srcPeer.getAbsoluteX() - dstPeer.getAbsoluteX(); rpt.y = y + srcPeer.getAbsoluteY() - dstPeer.getAbsoluteY(); } else if (dstPeer != null && XlibUtil.isRoot(src, dstPeer.getScreenNumber())) { // from root into peer rpt.x = x - dstPeer.getAbsoluteX(); rpt.y = y - dstPeer.getAbsoluteY(); } else if (srcPeer != null && XlibUtil.isRoot(dst, srcPeer.getScreenNumber())) { // from peer into root rpt.x = x + srcPeer.getAbsoluteX(); rpt.y = y + srcPeer.getAbsoluteY(); } else { rpt = XlibUtil.translateCoordinates(src, dst, new Point(x, y)); } return rpt; }
public static long xGetInputFocus() { XToolkit.awtLock(); try { return XlibWrapper.XGetInputFocus(XToolkit.getDisplay()); } finally { XToolkit.awtUnlock(); } }
public void toFront() { XToolkit.awtLock(); try { XlibWrapper.XRaiseWindow(XToolkit.getDisplay(), getWindow()); } finally { XToolkit.awtUnlock(); } }
/** Helper function to set W */ public final void setWMHints(XWMHints hints) { XToolkit.awtLock(); try { XlibWrapper.XSetWMHints(XToolkit.getDisplay(), getWindow(), hints.pData); } finally { XToolkit.awtUnlock(); } }
void flush() { XToolkit.awtLock(); try { XlibWrapper.XFlush(XToolkit.getDisplay()); } finally { XToolkit.awtUnlock(); } }
// don't use getLocationOnScreen() inherited from XDecoratedPeer public Point getLocationOnScreen() { XToolkit.awtLock(); try { return toGlobal(0, 0); } finally { XToolkit.awtUnlock(); } }
static long getScreenOfWindow(long window) { XToolkit.awtLock(); try { return XlibWrapper.getScreenOfWindow(XToolkit.getDisplay(), window); } finally { XToolkit.awtUnlock(); } }
/** set cursor */ public void setCursor(Cursor c) throws InvalidDnDOperationException { XToolkit.awtLock(); try { super.setCursor(c); } finally { XToolkit.awtUnlock(); } }
long getScreenNumber() { XToolkit.awtLock(); try { return XlibWrapper.XScreenNumberOfScreen(getScreen()); } finally { XToolkit.awtUnlock(); } }
protected void createCursor( byte[] xorMask, byte[] andMask, int width, int height, int fcolor, int bcolor, int xHotSpot, int yHotSpot) { XToolkit.awtLock(); try { long display = XToolkit.getDisplay(); long root_window = XlibWrapper.RootWindow(display, XlibWrapper.DefaultScreen(display)); long colormap = XToolkit.getDefaultXColormap(); XColor fore_color = new XColor(); fore_color.set_flags((byte) (XlibWrapper.DoRed | XlibWrapper.DoGreen | XlibWrapper.DoBlue)); fore_color.set_red((short) (((fcolor >> 16) & 0x000000ff) << 8)); fore_color.set_green((short) (((fcolor >> 8) & 0x000000ff) << 8)); fore_color.set_blue((short) (((fcolor >> 0) & 0x000000ff) << 8)); XlibWrapper.XAllocColor(display, colormap, fore_color.pData); XColor back_color = new XColor(); back_color.set_flags((byte) (XlibWrapper.DoRed | XlibWrapper.DoGreen | XlibWrapper.DoBlue)); back_color.set_red((short) (((bcolor >> 16) & 0x000000ff) << 8)); back_color.set_green((short) (((bcolor >> 8) & 0x000000ff) << 8)); back_color.set_blue((short) (((bcolor >> 0) & 0x000000ff) << 8)); XlibWrapper.XAllocColor(display, colormap, back_color.pData); long nativeXorMask = Native.toData(xorMask); long source = XlibWrapper.XCreateBitmapFromData(display, root_window, nativeXorMask, width, height); long nativeAndMask = Native.toData(andMask); long mask = XlibWrapper.XCreateBitmapFromData(display, root_window, nativeAndMask, width, height); long cursor = XlibWrapper.XCreatePixmapCursor( display, source, mask, fore_color.pData, back_color.pData, xHotSpot, yHotSpot); XlibWrapper.unsafe.freeMemory(nativeXorMask); XlibWrapper.unsafe.freeMemory(nativeAndMask); XlibWrapper.XFreePixmap(display, source); XlibWrapper.XFreePixmap(display, mask); back_color.dispose(); fore_color.dispose(); XGlobalCursorManager.setPData(this, cursor); } finally { XToolkit.awtUnlock(); } }
public void setShellSize(Rectangle rec) { if (insLog.isLoggable(Level.FINE)) insLog.fine("Setting shell size on " + this + " to " + rec); XToolkit.awtLock(); try { updateSizeHints(rec.x, rec.y, rec.width, rec.height); XlibWrapper.XResizeWindow(XToolkit.getDisplay(), getShell(), rec.width, rec.height); } finally { XToolkit.awtUnlock(); } }
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(); } }
protected void initClientLeader() { XToolkit.awtLock(); try { if (wm_client_leader == null) { wm_client_leader = XAtom.get("WM_CLIENT_LEADER"); } wm_client_leader.setWindowProperty(this, getXAWTRootWindow()); } finally { XToolkit.awtUnlock(); } }
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(); } }
/** Checks if the given window is a root window for the given screen */ static boolean isRoot(long rootCandidate, long screenNumber) { long root; XToolkit.awtLock(); try { root = XlibWrapper.RootWindow(XToolkit.getDisplay(), screenNumber); } finally { XToolkit.awtUnlock(); } return root == rootCandidate; }
void setWMClass(String[] cl) { if (cl.length != 2) { throw new IllegalArgumentException("WM_CLASS_NAME consists of exactly two strings"); } XToolkit.awtLock(); try { XAtom xa = XAtom.get(XAtom.XA_WM_CLASS); xa.setProperty8(getWindow(), cl[0] + '\0' + cl[1]); } finally { XToolkit.awtUnlock(); } }
static boolean processEvent(XEvent ev) { XToolkit.awtLock(); try { try { return theInstance.doProcessEvent(ev); } catch (XException e) { e.printStackTrace(); return false; } } finally { XToolkit.awtUnlock(); } }
protected void handleCorrectInsets(Insets correctWM) { XToolkit.awtLock(); try { /* * Ok, now see if we need adjust window size because * initial insets were wrong (most likely they were). */ Insets correction = difference(correctWM, currentInsets); if (insLog.isLoggable(Level.FINEST)) { insLog.log(Level.FINEST, "Corrention {0}", new Object[] {String.valueOf(correction)}); } if (!isNull(correction)) { /* * Actual insets account for menubar/warning label, * so we can't assign directly but must adjust them. */ add(currentInsets, correction); applyGuessedInsets(); // Fix for 6318109: PIT: Min Size is not honored properly when a // smaller size is specified in setSize(), XToolkit // update minimum size hints updateMinSizeHints(); /* * If this window has been sized by a pack() we need * to keep the interior geometry intact. Since pack() * computed width and height with wrong insets, we * must adjust the target dimensions appropriately. */ } if (insLog.isLoggable(Level.FINER)) insLog.finer("Dimensions before reparent: " + dimensions); dimensions.setInsets(getRealInsets()); insets_corrected = true; if (isMaximized()) { return; } if ((getHints().get_flags() & (USPosition | PPosition)) != 0) { reshape(dimensions, SET_BOUNDS, false); } else { reshape(dimensions, SET_SIZE, false); } } finally { XToolkit.awtUnlock(); } }
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); } } }
/** Xinerama-aware version of XlibWrapper.RootWindow method. */ public static long getRootWindow(int screenNumber) { XToolkit.awtLock(); try { X11GraphicsEnvironment x11ge = (X11GraphicsEnvironment) GraphicsEnvironment.getLocalGraphicsEnvironment(); if (x11ge.runningXinerama()) { // all the Xinerama windows share the same root window return XlibWrapper.RootWindow(XToolkit.getDisplay(), 0); } else { return XlibWrapper.RootWindow(XToolkit.getDisplay(), screenNumber); } } finally { XToolkit.awtUnlock(); } }
/** * Returns whether the XSHAPE extension available * * @since 1.7 */ static synchronized boolean isShapingSupported() { if (isShapingSupported == null) { XToolkit.awtLock(); try { isShapingSupported = XlibWrapper.XShapeQueryExtension( XToolkit.getDisplay(), XlibWrapper.larg1, XlibWrapper.larg2); } finally { XToolkit.awtUnlock(); } } return isShapingSupported.booleanValue(); }
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)); }
Point toLocal(int x, int y) { long root; XToolkit.awtLock(); try { root = XlibWrapper.RootWindow(XToolkit.getDisplay(), getScreenNumber()); } finally { XToolkit.awtUnlock(); } Point p = toOtherWindow(root, getContentWindow(), x, y); if (p != null) { return p; } else { return new Point(x, y); } }
void updateWMName() { String name = getWMName(); XToolkit.awtLock(); try { if (name == null) { name = " "; } XAtom nameAtom = XAtom.get(XAtom.XA_WM_NAME); nameAtom.setProperty(getWindow(), name); XAtom netNameAtom = XAtom.get("_NET_WM_NAME"); netNameAtom.setPropertyUTF8(getWindow(), name); } finally { XToolkit.awtUnlock(); } }