jdk-sandbox: comparison jdk/src/solaris/classes/sun/awt/X11/XDecoratedPeer.java

equal deleted inserted replaced

-:487e1aa949c4
+:ef327bd847c0
 import java.awt.event.ComponentEvent;
 import java.awt.event.InvocationEvent;
 import java.awt.event.WindowEvent;
-import java.util.logging.Level;
+import sun.util.logging.PlatformLogger;
-import java.util.logging.Logger;
 import sun.awt.ComponentAccessor;
 import sun.awt.SunToolkit;
 abstract class XDecoratedPeer extends XWindowPeer {
-private static final Logger log = Logger.getLogger("sun.awt.X11.XDecoratedPeer");
+private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XDecoratedPeer");
-private static final Logger insLog = Logger.getLogger("sun.awt.X11.insets.XDecoratedPeer");
+private static final PlatformLogger insLog = PlatformLogger.getLogger("sun.awt.X11.insets.XDecoratedPeer");
-private static final Logger focusLog = Logger.getLogger("sun.awt.X11.focus.XDecoratedPeer");
+private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.X11.focus.XDecoratedPeer");
-private static final Logger iconLog = Logger.getLogger("sun.awt.X11.icon.XDecoratedPeer");
+private static final PlatformLogger iconLog = PlatformLogger.getLogger("sun.awt.X11.icon.XDecoratedPeer");
 // Set to true when we get the first ConfigureNotify after being
 // reparented - indicates that WM has adopted the top-level.
 boolean configure_seen;
 boolean insets_corrected;
 applyGuessedInsets();
 Rectangle bounds = (Rectangle)params.get(BOUNDS);
 dimensions = new WindowDimensions(bounds, getRealInsets(), false);
 params.put(BOUNDS, dimensions.getClientRect());
-insLog.log(Level.FINE, "Initial dimensions {0}", new Object[] { dimensions });
+insLog.fine("Initial dimensions {0}", 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() & ~(XConstants.FocusChangeMask | XConstants.KeyPressMask | XConstants.KeyReleaseMask)));
 ComponentAccessor.getBackground(target),
 ComponentAccessor.getFont_NoClientCode(target));
 }
 public void setTitle(String title) {
-if (log.isLoggable(Level.FINE)) log.fine("Title is " + title);
+if (log.isLoggable(PlatformLogger.FINE)) log.fine("Title is " + title);
 winAttr.title = title;
 updateWMName();
 }
 protected String getWMName() {
 wm_set_insets = XWM.getInsetsFromExtents(getWindow());
 } else {
 wm_set_insets = XWM.getInsetsFromProp(getWindow(), changedAtom);
 }
-insLog.log(Level.FINER, "FRAME_EXTENTS: {0}", new Object[]{wm_set_insets});
+insLog.finer("FRAME_EXTENTS: {0}", wm_set_insets);
 if (wm_set_insets != null) {
 wm_set_insets = copy(wm_set_insets);
 }
 return wm_set_insets;
 long reparent_serial = 0;
 public void handleReparentNotifyEvent(XEvent xev) {
 XReparentEvent  xe = xev.get_xreparent();
-if (insLog.isLoggable(Level.FINE)) insLog.fine(xe.toString());
+if (insLog.isLoggable(PlatformLogger.FINE)) insLog.fine(xe.toString());
 reparent_serial = xe.get_serial();
 XToolkit.awtLock();
 try {
 long root = XlibWrapper.RootWindow(XToolkit.getDisplay(), getScreenNumber());
 insets_corrected = false;
 // Check if we have insets provided by the WM
 Insets correctWM = getWMSetInsets(null);
 if (correctWM != null) {
-insLog.log(Level.FINER, "wm-provided insets {0}", new Object[]{correctWM});
+insLog.finer("wm-provided insets {0}", 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;
 }
 } else {
 correctWM = XWM.getWM().getInsets(this, xe.get_window(), xe.get_parent());
 if (correctWM != null) {
-insLog.log(Level.FINER, "correctWM {0}", new Object[] {correctWM});
+insLog.finer("correctWM {0}", correctWM);
 } else {
-insLog.log(Level.FINER, "correctWM insets are not available, waiting for configureNotify");
+insLog.finer("correctWM insets are not available, waiting for configureNotify");
 }
 }
 if (correctWM != null) {
 handleCorrectInsets(correctWM);
 /*
 * Ok, now see if we need adjust window size because
 * initial insets were wrong (most likely they were).
 */
 Insets correction = difference(correctWM, currentInsets);
-insLog.log(Level.FINEST, "Corrention {0}", new Object[] {correction});
+insLog.finest("Corrention {0}", correction);
 if (!isNull(correction)) {
 currentInsets = copy(correctWM);
 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 (insLog.isLoggable(Level.FINER)) insLog.finer("Dimensions before reparent: " + dimensions);
+if (insLog.isLoggable(PlatformLogger.FINER)) insLog.finer("Dimensions before reparent: " + dimensions);
 dimensions.setInsets(getRealInsets());
 insets_corrected = true;
 if (isMaximized()) {
 }
 public Insets getInsets() {
 Insets in = copy(getRealInsets());
 in.top += getMenuBarHeight();
-if (insLog.isLoggable(Level.FINEST)) {
+if (insLog.isLoggable(PlatformLogger.FINEST)) {
-insLog.log(Level.FINEST, "Get insets returns {0}", new Object[] {in});
+insLog.finest("Get insets returns {0}", in);
 }
 return in;
 }
 boolean gravityBug() {
 // 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)) {
+if (insLog.isLoggable(PlatformLogger.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
 newDimensions = new WindowDimensions(newBounds, insets, newDimensions.isClientSizeSet());
 }
 XToolkit.awtLock();
 try {
 if (!isReparented() || !isVisible()) {
-insLog.log(Level.FINE, "- not reparented({0}) or not visible({1}), default reshape",
+insLog.fine("- not reparented({0}) or not visible({1}), default reshape",
-new Object[] {Boolean.valueOf(isReparented()), Boolean.valueOf(visible)});
+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.
 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}",
+if (insLog.isLoggable(PlatformLogger.FINE))
-new Object[] {operationToString(operation), dims});
+insLog.fine("For the operation {0} new dimensions are {1}",
+operationToString(operation), dims);
 reshape(dims, operation, userReshape);
 }
 // This method gets overriden in XFramePeer & XDialogPeer.
 boolean no_reparent_artifacts = false;
 public void handleConfigureNotifyEvent(XEvent xev) {
 assert (SunToolkit.isAWTLockHeldByCurrentThread());
 XConfigureEvent xe = xev.get_xconfigure();
-insLog.log(Level.FINE, "Configure notify {0}", new Object[] {xe});
+insLog.fine("Configure notify {0}", xe);
 // XXX: should really only consider synthetic events, but
 if (isReparented()) {
 configure_seen = true;
 }
 * 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)) {
+if (insLog.isLoggable(PlatformLogger.FINE)) {
-insLog.log(Level.FINE, "reparented={0}, visible={1}, WM={2}, decorations={3}",
+insLog.fine("reparented={0}, visible={1}, WM={2}, decorations={3}",
-new Object[] {isReparented(), isVisible(), runningWM, getDecorations()});
+isReparented(), isVisible(), runningWM, getDecorations());
 }
 if (!isReparented() && isVisible() && runningWM != XWM.NO_WM
 &&  !XWM.isNonReparentingWM()
 && getDecorations() != XWindowAttributesData.AWT_DECOR_NONE) {
 insLog.fine("- visible but not reparented, skipping");
 }
 //Last chance to correct insets
 if (!insets_corrected && getDecorations() != XWindowAttributesData.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 (insLog.isLoggable(PlatformLogger.FINER)) {
 if (correctWM != null) {
 insLog.finer("Configure notify - insets : " + correctWM);
 } else {
 insLog.finer("Configure notify - insets are still not available");
 }
 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[]{xlocation});
+if (log.isLoggable(PlatformLogger.FINE)) log.fine("New X location: {0}", xlocation);
 if (xlocation != null) {
 newLocation = xlocation;
 }
 break;
 }
 new WindowDimensions(newLocation,
 new Dimension(xe.get_width(), xe.get_height()),
 copy(currentInsets),
 true);
-insLog.log(Level.FINER, "Insets are {0}, new dimensions {1}",
+insLog.finer("Insets are {0}, new dimensions {1}",
-new Object[] {currentInsets, newDimensions});
+currentInsets, newDimensions);
 checkIfOnNewScreen(newDimensions.getBounds());
 Point oldLocation = getLocation();
 dimensions = newDimensions;
 checkShellRectSize(shellRect);
 checkShellRectPos(shellRect);
 }
 public void setShellBounds(Rectangle rec) {
-if (insLog.isLoggable(Level.FINE)) insLog.fine("Setting shell bounds on " +
+if (insLog.isLoggable(PlatformLogger.FINE)) insLog.fine("Setting shell bounds 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);
 XlibWrapper.XMoveWindow(XToolkit.getDisplay(), getShell(), rec.x, rec.y);
 finally {
 XToolkit.awtUnlock();
 }
 }
 public void setShellSize(Rectangle rec) {
-if (insLog.isLoggable(Level.FINE)) insLog.fine("Setting shell size on " +
+if (insLog.isLoggable(PlatformLogger.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 setShellPosition(Rectangle rec) {
-if (insLog.isLoggable(Level.FINE)) insLog.fine("Setting shell position on " +
+if (insLog.isLoggable(PlatformLogger.FINE)) insLog.fine("Setting shell position on " +
 this + " to " + rec);
 XToolkit.awtLock();
 try {
 updateSizeHints(rec.x, rec.y, rec.width, rec.height);
 XlibWrapper.XMoveWindow(XToolkit.getDisplay(), getShell(), rec.x, rec.y);
 }
 try {
 if (configure_seen) {
 return toGlobal(0,0);
 } else {
 Point location = target.getLocation();
-if (insLog.isLoggable(Level.FINE))
+if (insLog.isLoggable(PlatformLogger.FINE))
-insLog.log(Level.FINE, "getLocationOnScreen {0} not reparented: {1} ",
+insLog.fine("getLocationOnScreen {0} not reparented: {1} ",
-new Object[] {this, location});
+this, location);
 return location;
 }
 } finally {
 XToolkit.awtUnlock();
 }
 int getFunctions() {
 return winAttr.functions;
 }
 public void setVisible(boolean vis) {
-log.log(Level.FINER, "Setting {0} to visible {1}", new Object[] {this, Boolean.valueOf(vis)});
+log.finer("Setting {0} to visible {1}", this, Boolean.valueOf(vis));
 if (vis && !isVisible()) {
 XWM.setShellDecor(this);
 super.setVisible(vis);
 if (winAttr.isResizable) {
 //Fix for 4320050: Minimum size for java.awt.Frame is not being enforced.
 }
 }
 }
 private void handleWmTakeFocus(XClientMessageEvent cl) {
-focusLog.log(Level.FINE, "WM_TAKE_FOCUS on {0}", new Object[]{this});
+focusLog.fine("WM_TAKE_FOCUS on {0}", this);
 requestWindowFocus(cl.get_data(1), true);
 }
 /**
 * Requests focus to this decorated top-level by requesting X input focus
 protected void requestXFocus(long time, boolean timeProvided) {
 // We have proxied focus mechanism - instead of shell the focus is held
 // by "proxy" - invisible mapped window. When we want to set X input focus to
 // toplevel set it on proxy instead.
 if (focusProxy == null) {
-if (focusLog.isLoggable(Level.FINE)) focusLog.warning("Focus proxy is null for " + this);
+if (focusLog.isLoggable(PlatformLogger.FINE)) focusLog.warning("Focus proxy is null for " + this);
 } else {
-if (focusLog.isLoggable(Level.FINE)) focusLog.fine("Requesting focus to proxy: " + focusProxy);
+if (focusLog.isLoggable(PlatformLogger.FINE)) focusLog.fine("Requesting focus to proxy: " + focusProxy);
 if (timeProvided) {
 focusProxy.xRequestFocus(time);
 } else {
 focusProxy.xRequestFocus();
 }
 // If this is Frame or Dialog we can't assure focus request success - but we still can try
 // If this is Window and its owner Frame is active we can be sure request succedded.
 Window focusedWindow = XKeyboardFocusManagerPeer.getCurrentNativeFocusedWindow();
 Window activeWindow = XWindowPeer.getDecoratedOwner(focusedWindow);
-focusLog.log(Level.FINER, "Current window is: active={0}, focused={1}",
+focusLog.finer("Current window is: active={0}, focused={1}",
-new Object[]{ Boolean.valueOf(target == activeWindow),
+Boolean.valueOf(target == activeWindow),
-Boolean.valueOf(target == focusedWindow)});
+Boolean.valueOf(target == focusedWindow));
 XWindowPeer toFocus = this;
 while (toFocus.nextTransientFor != null) {
 toFocus = toFocus.nextTransientFor;
 }

changeset 3938	ef327bd847c0
parent 2802	d05a9dcc8296
child 4214	0fa32d38146b