XContentWindow createContent(WindowDimensions dims) { 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; } return new XContentWindow(this, rec); }
void preInit(XCreateWindowParams params) { super.preInit(params); if (!resize_request.isInterned()) { resize_request.intern(false); } winAttr.initialFocus = true; currentInsets = new Insets(0, 0, 0, 0); // replacemenet for wdata->top, left, bottom, right applyGuessedInsets(); Rectangle bounds = (Rectangle) params.get(BOUNDS); dimensions = new WindowDimensions(bounds, getRealInsets(), false); params.put(BOUNDS, dimensions.getClientRect()); if (insLog.isLoggable(Level.FINE)) { insLog.log(Level.FINE, "Initial dimensions {0}", new Object[] {String.valueOf(dimensions)}); } // Deny default processing of these events on the shell - proxy will take care of // them instead Long eventMask = (Long) params.get(EVENT_MASK); params.add( EVENT_MASK, Long.valueOf(eventMask.longValue() & ~(FocusChangeMask | KeyPressMask | KeyReleaseMask))); }
public void setResizable(boolean resizable) { int fs = winAttr.functions; if (!isResizable() && resizable) { insets = currentInsets = new Insets(0, 0, 0, 0); resetWMSetInsets(); if (!isEmbedded()) { setReparented(false); } winAttr.isResizable = resizable; if ((fs & MWM_FUNC_ALL) != 0) { fs &= ~(MWM_FUNC_RESIZE | MWM_FUNC_MAXIMIZE); } else { fs |= (MWM_FUNC_RESIZE | MWM_FUNC_MAXIMIZE); } winAttr.functions = fs; XWM.setShellResizable(this); } else if (isResizable() && !resizable) { insets = currentInsets = new Insets(0, 0, 0, 0); resetWMSetInsets(); if (!isEmbedded()) { setReparented(false); } winAttr.isResizable = resizable; if ((fs & MWM_FUNC_ALL) != 0) { fs |= (MWM_FUNC_RESIZE | MWM_FUNC_MAXIMIZE); } else { fs &= ~(MWM_FUNC_RESIZE | MWM_FUNC_MAXIMIZE); } winAttr.functions = fs; XWM.setShellNotResizable(this, dimensions, dimensions.getScreenBounds(), false); } }
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(); } }
/** @param x, y, width, heith - dimensions of the window with insets */ private void reshape(int x, int y, int width, int height, int operation, boolean userReshape) { Rectangle newRec; boolean setClient = false; WindowDimensions dims = new WindowDimensions(dimensions); switch (operation & (~NO_EMBEDDED_CHECK)) { case SET_LOCATION: // Set location always sets bounds location. However, until the window is mapped we // should use client coordinates dims.setLocation(x, y); break; case SET_SIZE: // Set size sets bounds size. However, until the window is mapped we // should use client coordinates dims.setSize(width, height); break; case SET_CLIENT_SIZE: { // Sets client rect size. Width and height contain insets. Insets in = currentInsets; width -= in.left + in.right; height -= in.top + in.bottom; dims.setClientSize(width, height); break; } case SET_BOUNDS: default: dims.setLocation(x, y); dims.setSize(width, height); break; } if (insLog.isLoggable(Level.FINE)) { insLog.log( Level.FINE, "For the operation {0} new dimensions are {1}", new Object[] {operationToString(operation), String.valueOf(dims)}); } reshape(dims, operation, userReshape); }
public int getAbsoluteY() { // NOTE: returning this peer's location which is shell location return dimensions.getScreenBounds().y; }
public Point getLocation() { return dimensions.getLocation(); }
public int getY() { return dimensions.getLocation().y; }
public int getX() { return dimensions.getLocation().x; }
public Dimension getSize() { return dimensions.getSize(); }
public Rectangle getBounds() { return dimensions.getBounds(); }
Rectangle getShellBounds() { return dimensions.getClientRect(); }
public void handleReparentNotifyEvent(XEvent xev) { XReparentEvent xe = xev.get_xreparent(); if (insLog.isLoggable(Level.FINE)) insLog.fine(xe.toString()); reparent_serial = xe.get_serial(); XToolkit.awtLock(); try { long root = XlibWrapper.RootWindow(XToolkit.getDisplay(), getScreenNumber()); if (isEmbedded()) { setReparented(true); insets_corrected = true; return; } Component t = (Component) target; if (getDecorations() == winAttr.AWT_DECOR_NONE) { setReparented(true); insets_corrected = true; reshape(dimensions, SET_SIZE, false); } else if (xe.get_parent() == root) { configure_seen = false; insets_corrected = false; /* * We can be repareted to root for two reasons: * . setVisible(false) * . WM exited */ if (isVisible()) { /* WM exited */ /* Work around 4775545 */ XWM.getWM().unshadeKludge(this); insLog.fine("- WM exited"); } else { insLog.fine(" - reparent due to hide"); } } else { /* reparented to WM frame, figure out our insets */ setReparented(true); insets_corrected = false; // Check if we have insets provided by the WM Insets correctWM = getWMSetInsets(null); if (correctWM != null) { if (insLog.isLoggable(Level.FINER)) { insLog.log( Level.FINER, "wm-provided insets {0}", new Object[] {String.valueOf(correctWM)}); } // If these insets are equal to our current insets - no actions are necessary Insets dimInsets = dimensions.getInsets(); if (correctWM.equals(dimInsets)) { insLog.finer("Insets are the same as estimated - no additional reshapes necessary"); no_reparent_artifacts = true; insets_corrected = true; applyGuessedInsets(); return; } } else { correctWM = XWM.getWM().getInsets(this, xe.get_window(), xe.get_parent()); if (correctWM != null) { if (insLog.isLoggable(Level.FINER)) { insLog.log(Level.FINER, "correctWM {0}", new Object[] {String.valueOf(correctWM)}); } } else { insLog.log( Level.FINER, "correctWM insets are not available, waiting for configureNotify"); } } if (correctWM != null) { handleCorrectInsets(correctWM); } } } finally { XToolkit.awtUnlock(); } }
public void handleConfigureNotifyEvent(XEvent xev) { assert (SunToolkit.isAWTLockHeldByCurrentThread()); XConfigureEvent xe = xev.get_xconfigure(); if (insLog.isLoggable(Level.FINE)) { insLog.log(Level.FINE, "Configure notify {0}", new Object[] {String.valueOf(xe)}); } // XXX: should really only consider synthetic events, but if (isReparented()) { configure_seen = true; } if (!isMaximized() && (xe.get_serial() == reparent_serial || xe.get_window() != getShell()) && !no_reparent_artifacts) { insLog.fine("- reparent artifact, skipping"); return; } no_reparent_artifacts = false; /** * When there is a WM we receive some CN before being visible and after. We should skip all CN * which are before being visible, because we assume the gravity is in action while it is not * yet. * * <p>When there is no WM we receive CN only _before_ being visible. We should process these * CNs. */ if (!isVisible() && XWM.getWMID() != XWM.NO_WM) { insLog.fine(" - not visible, skipping"); return; } /* * Some window managers configure before we are reparented and * the send event flag is set! ugh... (Enlighetenment for one, * possibly MWM as well). If we haven't been reparented yet * this is just the WM shuffling us into position. Ignore * it!!!! or we wind up in a bogus location. */ int runningWM = XWM.getWMID(); if (insLog.isLoggable(Level.FINE)) { insLog.log( Level.FINE, "reparented={0}, visible={1}, WM={2}, decorations={3}", new Object[] {isReparented(), isVisible(), runningWM, getDecorations()}); } if (!isReparented() && isVisible() && runningWM != XWM.NO_WM && !XWM.isNonReparentingWM() && getDecorations() != winAttr.AWT_DECOR_NONE) { insLog.fine("- visible but not reparented, skipping"); return; } // Last chance to correct insets if (!insets_corrected && getDecorations() != winAttr.AWT_DECOR_NONE) { long parent = XlibUtil.getParentWindow(window); Insets correctWM = (parent != -1) ? XWM.getWM().getInsets(this, window, parent) : null; if (insLog.isLoggable(Level.FINER)) { if (correctWM != null) { insLog.finer("Configure notify - insets : " + correctWM); } else { insLog.finer("Configure notify - insets are still not available"); } } if (correctWM != null) { handleCorrectInsets(correctWM); } else { // Only one attempt to correct insets is made (to lower risk) // if insets are still not available we simply set the flag insets_corrected = true; } } updateChildrenSizes(); // Bounds of the window Rectangle targetBounds = new Rectangle( ComponentAccessor.getX((Component) target), ComponentAccessor.getY((Component) target), ComponentAccessor.getWidth((Component) target), ComponentAccessor.getHeight((Component) target)); Point newLocation = targetBounds.getLocation(); if (xe.get_send_event() || runningWM == XWM.NO_WM || XWM.isNonReparentingWM()) { // Location, Client size + insets newLocation = new Point(xe.get_x() - currentInsets.left, xe.get_y() - currentInsets.top); } else { // CDE/MWM/Metacity/Sawfish bug: if shell is resized using // top or left border, we don't receive synthetic // ConfigureNotify, only the one from X with zero // coordinates. This is the workaround to get real // location, 6261336 switch (XWM.getWMID()) { case XWM.CDE_WM: case XWM.MOTIF_WM: case XWM.METACITY_WM: case XWM.SAWFISH_WM: { Point xlocation = queryXLocation(); if (log.isLoggable(Level.FINE)) { log.log(Level.FINE, "New X location: {0}", new Object[] {String.valueOf(xlocation)}); } if (xlocation != null) { newLocation = xlocation; } break; } default: break; } } WindowDimensions newDimensions = new WindowDimensions( newLocation, new Dimension(xe.get_width(), xe.get_height()), copy(currentInsets), true); if (insLog.isLoggable(Level.FINER)) { insLog.log( Level.FINER, "Insets are {0}, new dimensions {1}", new Object[] {String.valueOf(currentInsets), String.valueOf(newDimensions)}); } checkIfOnNewScreen(newDimensions.getBounds()); Point oldLocation = getLocation(); dimensions = newDimensions; if (!newLocation.equals(oldLocation)) { handleMoved(newDimensions); } reconfigureContentWindow(newDimensions); updateChildrenSizes(); }
// Coordinates are that of the target // Called only on Toolkit thread public void reshape(WindowDimensions newDimensions, int op, boolean userReshape) { if (insLog.isLoggable(Level.FINE)) { insLog.fine( "Reshaping " + this + " to " + newDimensions + " op " + op + " user reshape " + userReshape); } if (userReshape) { // We handle only userReshape == true cases. It means that // if the window manager or any other part of the windowing // system sets inappropriate size for this window, we can // do nothing but accept it. Rectangle reqBounds = newDimensions.getBounds(); Rectangle newBounds = constrainBounds(reqBounds.x, reqBounds.y, reqBounds.width, reqBounds.height); Insets insets = newDimensions.getInsets(); Rectangle clientBounds = new Rectangle( newBounds.x, newBounds.y, newBounds.width - insets.left - insets.right, newBounds.height - insets.top - insets.bottom); newDimensions = new WindowDimensions( newDimensions.isClientSizeSet() ? clientBounds : newBounds, insets, newDimensions.isClientSizeSet()); } XToolkit.awtLock(); try { if (!isReparented() || !isVisible()) { insLog.log( Level.FINE, "- not reparented({0}) or not visible({1}), default reshape", new Object[] {Boolean.valueOf(isReparented()), Boolean.valueOf(visible)}); // Fix for 6323293. // This actually is needed to preserve compatibility with previous releases - // some of licensees are expecting componentMoved event on invisible one while // its location changes. Point oldLocation = getLocation(); Point newLocation = new Point( ComponentAccessor.getX((Component) target), ComponentAccessor.getY((Component) target)); if (!newLocation.equals(oldLocation)) { handleMoved(newDimensions); } dimensions = new WindowDimensions(newDimensions); updateSizeHints(dimensions); Rectangle client = dimensions.getClientRect(); checkShellRect(client); setShellBounds(client); if (content != null && !content.getSize().equals(newDimensions.getSize())) { reconfigureContentWindow(newDimensions); } return; } int wm = XWM.getWMID(); updateChildrenSizes(); applyGuessedInsets(); Rectangle shellRect = newDimensions.getClientRect(); if (gravityBug()) { Insets in = newDimensions.getInsets(); shellRect.translate(in.left, in.top); } if ((op & NO_EMBEDDED_CHECK) == 0 && isEmbedded()) { shellRect.setLocation(0, 0); } checkShellRectSize(shellRect); if (!isEmbedded()) { checkShellRectPos(shellRect); } op = op & ~NO_EMBEDDED_CHECK; if (op == SET_LOCATION) { setShellPosition(shellRect); } else if (isResizable()) { if (op == SET_BOUNDS) { setShellBounds(shellRect); } else { setShellSize(shellRect); } } else { XWM.setShellNotResizable(this, newDimensions, shellRect, true); if (op == SET_BOUNDS) { setShellPosition(shellRect); } } reconfigureContentWindow(newDimensions); } finally { XToolkit.awtUnlock(); } }
void updateSizeHints(WindowDimensions dims) { Rectangle rec = dims.getClientRect(); checkShellRect(rec); updateSizeHints(rec.x, rec.y, rec.width, rec.height); }
public void handleMoved(WindowDimensions dims) { Point loc = dims.getLocation(); ComponentAccessor.setX((Component) target, loc.x); ComponentAccessor.setY((Component) target, loc.y); postEvent(new ComponentEvent(target, ComponentEvent.COMPONENT_MOVED)); }