From a09ca6db73676445d032d4300cf2beeb99ce590c Mon Sep 17 00:00:00 2001 From: dcherepanov Date: Thu, 20 Aug 2009 12:46:43 +0400 Subject: [PATCH] 6664512: Component and [Default]KeyboardFocusManager pass security sensitive objects to loggers Summary: toString is called on security sensitive objects Reviewed-by: art, hawtin --- src/share/classes/java/awt/Component.java | 2 +- .../java/awt/DefaultKeyboardFocusManager.java | 60 +++++++++++++------ .../java/awt/KeyboardFocusManager.java | 23 +++---- src/share/classes/sun/awt/DebugSettings.java | 2 +- .../classes/sun/awt/X11/XBaseWindow.java | 17 ++++-- .../sun/awt/X11/XCheckboxMenuItemPeer.java | 4 -- .../classes/sun/awt/X11/XComponentPeer.java | 22 +++++-- .../classes/sun/awt/X11/XContentWindow.java | 6 +- .../classes/sun/awt/X11/XDecoratedPeer.java | 53 +++++++++++----- .../sun/awt/X11/XDropTargetProtocol.java | 5 +- .../sun/awt/X11/XFocusProxyWindow.java | 1 - .../classes/sun/awt/X11/XFramePeer.java | 4 +- .../classes/sun/awt/X11/XIconWindow.java | 11 +++- .../classes/sun/awt/X11/XInputMethod.java | 5 +- .../classes/sun/awt/X11/XMenuItemPeer.java | 2 - .../classes/sun/awt/X11/XNETProtocol.java | 27 +++++++-- .../classes/sun/awt/X11/XProtocol.java | 6 +- .../classes/sun/awt/X11/XQueryTree.java | 1 - src/solaris/classes/sun/awt/X11/XToolkit.java | 19 ++++-- .../classes/sun/awt/X11/XTrayIconPeer.java | 43 ++++++++----- src/solaris/classes/sun/awt/X11/XWM.java | 48 +++++++++++---- src/solaris/classes/sun/awt/X11/XWindow.java | 30 +++++++--- .../classes/sun/awt/X11/XWindowPeer.java | 56 +++++++++++++---- .../sun/awt/windows/WMenuItemPeer.java | 2 +- .../classes/sun/awt/windows/WPanelPeer.java | 1 - 25 files changed, 317 insertions(+), 133 deletions(-) diff --git a/src/share/classes/java/awt/Component.java b/src/share/classes/java/awt/Component.java index 91347ad1b..3ecf30c51 100644 --- a/src/share/classes/java/awt/Component.java +++ b/src/share/classes/java/awt/Component.java @@ -4477,7 +4477,7 @@ public abstract class Component implements ImageObserver, MenuContainer, } if (eventLog.isLoggable(Level.FINEST)) { - eventLog.log(Level.FINEST, "{0}", e); + eventLog.log(Level.FINEST, "{0}", String.valueOf(e)); } /* diff --git a/src/share/classes/java/awt/DefaultKeyboardFocusManager.java b/src/share/classes/java/awt/DefaultKeyboardFocusManager.java index 71342bdae..d7e5cba7c 100644 --- a/src/share/classes/java/awt/DefaultKeyboardFocusManager.java +++ b/src/share/classes/java/awt/DefaultKeyboardFocusManager.java @@ -380,7 +380,7 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { // should receive focus first if (focusLog.isLoggable(Level.FINER)) { focusLog.log(Level.FINER, "tempLost {0}, toFocus {1}", - new Object[]{tempLost, toFocus}); + new Object[]{String.valueOf(tempLost), String.valueOf(toFocus)}); } if (tempLost != null) { tempLost.requestFocusInWindow(CausedFocusEvent.Cause.ACTIVATION); @@ -448,7 +448,8 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { Component newFocusOwner = fe.getComponent(); if (oldFocusOwner == newFocusOwner) { if (focusLog.isLoggable(Level.FINE)) { - focusLog.log(Level.FINE, "Skipping {0} because focus owner is the same", new Object[] {e}); + focusLog.log(Level.FINE, "Skipping {0} because focus owner is the same", + new Object[] {String.valueOf(e)}); } // We can't just drop the event - there could be // type-ahead markers associated with it. @@ -565,16 +566,20 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { FocusEvent fe = (FocusEvent)e; Component currentFocusOwner = getGlobalFocusOwner(); if (currentFocusOwner == null) { - if (focusLog.isLoggable(Level.FINE)) focusLog.log(Level.FINE, "Skipping {0} because focus owner is null", - new Object[] {e}); + if (focusLog.isLoggable(Level.FINE)) { + focusLog.log(Level.FINE, "Skipping {0} because focus owner is null", + new Object[] {String.valueOf(e)}); + } break; } // Ignore cases where a Component loses focus to itself. // If we make a mistake because of retargeting, then the // FOCUS_GAINED handler will correct it. if (currentFocusOwner == fe.getOppositeComponent()) { - if (focusLog.isLoggable(Level.FINE)) focusLog.log(Level.FINE, "Skipping {0} because current focus owner is equal to opposite", - new Object[] {e}); + if (focusLog.isLoggable(Level.FINE)) { + focusLog.log(Level.FINE, "Skipping {0} because current focus owner is equal to opposite", + new Object[] {String.valueOf(e)}); + } break; } @@ -642,9 +647,11 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { Window losingFocusWindow = we.getWindow(); Window activeWindow = getGlobalActiveWindow(); Window oppositeWindow = we.getOppositeWindow(); - if (focusLog.isLoggable(Level.FINE)) focusLog.log(Level.FINE, "Active {0}, Current focused {1}, losing focus {2} opposite {3}", - new Object[] {activeWindow, currentFocusedWindow, - losingFocusWindow, oppositeWindow}); + if (focusLog.isLoggable(Level.FINE)) { + focusLog.log(Level.FINE, "Active {0}, Current focused {1}, losing focus {2} opposite {3}", + new Object[] {String.valueOf(activeWindow), String.valueOf(currentFocusedWindow), + String.valueOf(losingFocusWindow), String.valueOf(oppositeWindow)}); + } if (currentFocusedWindow == null) { break; } @@ -828,7 +835,10 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { } } if (ke != null) { - focusLog.log(Level.FINER, "Pumping approved event {0}", new Object[] {ke}); + if (focusLog.isLoggable(Level.FINER)) { + focusLog.log(Level.FINER, "Pumping approved event {0}", + new Object[] {String.valueOf(ke)}); + } enqueuedKeyEvents.removeFirst(); } } @@ -850,7 +860,7 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { Iterator iter = typeAheadMarkers.iterator(); while (iter.hasNext()) { TypeAheadMarker marker = (TypeAheadMarker)iter.next(); - focusLog.log(Level.FINEST, " {0}", marker); + focusLog.log(Level.FINEST, " {0}", String.valueOf(marker)); } } } @@ -878,7 +888,10 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { // The fix is rolled out. if (ke.getWhen() > marker.after) { - focusLog.log(Level.FINER, "Storing event {0} because of marker {1}", new Object[] {ke, marker}); + if (focusLog.isLoggable(Level.FINER)) { + focusLog.log(Level.FINER, "Storing event {0} because of marker {1}", + new Object[] {String.valueOf(ke), String.valueOf(marker)}); + } enqueuedKeyEvents.addLast(ke); return true; } @@ -890,7 +903,10 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { } case FocusEvent.FOCUS_GAINED: - focusLog.log(Level.FINEST, "Markers before FOCUS_GAINED on {0}", new Object[] {target}); + if (focusLog.isLoggable(Level.FINEST)) { + focusLog.log(Level.FINEST, "Markers before FOCUS_GAINED on {0}", + new Object[] {String.valueOf(target)}); + } dumpMarkers(); // Search the marker list for the first marker tied to // the Component which just gained focus. Then remove @@ -919,10 +935,14 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { } } else { // Exception condition - event without marker - focusLog.log(Level.FINER, "Event without marker {0}", e); + if (focusLog.isLoggable(Level.FINER)) { + focusLog.log(Level.FINER, "Event without marker {0}", String.valueOf(e)); + } } } + focusLog.log(Level.FINEST, "Markers after FOCUS_GAINED"); + dumpMarkers(); redispatchEvent(target, e); @@ -1159,8 +1179,10 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { return; } - focusLog.log(Level.FINER, "Enqueue at {0} for {1}", - new Object[] {after, untilFocused}); + if (focusLog.isLoggable(Level.FINER)) { + focusLog.log(Level.FINER, "Enqueue at {0} for {1}", + new Object[] {after, String.valueOf(untilFocused)}); + } int insertionIndex = 0, i = typeAheadMarkers.size(); @@ -1199,8 +1221,10 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager { return; } - focusLog.log(Level.FINER, "Dequeue at {0} for {1}", - new Object[] {after, untilFocused}); + if (focusLog.isLoggable(Level.FINER)) { + focusLog.log(Level.FINER, "Dequeue at {0} for {1}", + new Object[] {after, String.valueOf(untilFocused)}); + } TypeAheadMarker marker; ListIterator iter = typeAheadMarkers.listIterator diff --git a/src/share/classes/java/awt/KeyboardFocusManager.java b/src/share/classes/java/awt/KeyboardFocusManager.java index 521c70403..fd412d864 100644 --- a/src/share/classes/java/awt/KeyboardFocusManager.java +++ b/src/share/classes/java/awt/KeyboardFocusManager.java @@ -611,7 +611,7 @@ public abstract class KeyboardFocusManager void setNativeFocusOwner(Component comp) { if (focusLog.isLoggable(Level.FINEST)) { focusLog.log(Level.FINEST, "Calling peer {0} setCurrentFocusOwner for {1}", - new Object[] {peer, comp}); + new Object[] {String.valueOf(peer), String.valueOf(comp)}); } peer.setCurrentFocusOwner(comp); } @@ -2363,20 +2363,20 @@ public abstract class KeyboardFocusManager Window nativeFocusedWindow = thisManager.getNativeFocusedWindow(); if (focusLog.isLoggable(Level.FINER)) { focusLog.log(Level.FINER, "SNFH for {0} in {1}", - new Object[] {descendant, heavyweight}); + new Object[] {String.valueOf(descendant), String.valueOf(heavyweight)}); } if (focusLog.isLoggable(Level.FINEST)) { focusLog.log(Level.FINEST, "0. Current focus owner {0}", - currentFocusOwner); + String.valueOf(currentFocusOwner)); focusLog.log(Level.FINEST, "0. Native focus owner {0}", - nativeFocusOwner); + String.valueOf(nativeFocusOwner)); focusLog.log(Level.FINEST, "0. Native focused window {0}", - nativeFocusedWindow); + String.valueOf(nativeFocusedWindow)); } synchronized (heavyweightRequests) { HeavyweightFocusRequest hwFocusRequest = getLastHWRequest(); if (focusLog.isLoggable(Level.FINEST)) { - focusLog.log(Level.FINEST, "Request {0}", hwFocusRequest); + focusLog.log(Level.FINEST, "Request {0}", String.valueOf(hwFocusRequest)); } if (hwFocusRequest == null && heavyweight == nativeFocusOwner) @@ -2385,7 +2385,7 @@ public abstract class KeyboardFocusManager // Redundant request. if (focusLog.isLoggable(Level.FINEST)) focusLog.log(Level.FINEST, "1. SNFH_FAILURE for {0}", - descendant); + String.valueOf(descendant)); return SNFH_FAILURE; } @@ -2418,7 +2418,7 @@ public abstract class KeyboardFocusManager SunToolkit.postEvent(descendant.appContext, newFocusOwnerEvent); if (focusLog.isLoggable(Level.FINEST)) - focusLog.log(Level.FINEST, "2. SNFH_HANDLED for {0}", descendant); + focusLog.log(Level.FINEST, "2. SNFH_HANDLED for {0}", String.valueOf(descendant)); return SNFH_SUCCESS_HANDLED; } else if (hwFocusRequest != null && hwFocusRequest.heavyweight == heavyweight) { @@ -2857,11 +2857,12 @@ public abstract class KeyboardFocusManager KeyboardFocusManager manager = getCurrentKeyboardFocusManager(); if (focusLog.isLoggable(Level.FINER)) { if (event instanceof FocusEvent || event instanceof WindowEvent) { - focusLog.log(Level.FINER, ">>> {0}", new Object[] {event}); + focusLog.log(Level.FINER, ">>> {0}", new Object[] {String.valueOf(event)}); } if (focusLog.isLoggable(Level.FINER) && event instanceof KeyEvent) { - focusLog.log(Level.FINER, " focus owner is {0}", new Object[] {manager.getGlobalFocusOwner()}); - focusLog.log(Level.FINER, ">>> {0}", new Object[] {event}); + focusLog.log(Level.FINER, " focus owner is {0}", + new Object[] {String.valueOf(manager.getGlobalFocusOwner())}); + focusLog.log(Level.FINER, ">>> {0}", new Object[] {String.valueOf(event)}); } } diff --git a/src/share/classes/sun/awt/DebugSettings.java b/src/share/classes/sun/awt/DebugSettings.java index 0d2aaaf62..ac343ffac 100644 --- a/src/share/classes/sun/awt/DebugSettings.java +++ b/src/share/classes/sun/awt/DebugSettings.java @@ -129,7 +129,7 @@ final class DebugSettings { // echo the initial property settings to stdout if (log.isLoggable(Level.FINE)) { - log.log(Level.FINE, "DebugSettings:\n{0}", this); + log.log(Level.FINE, "DebugSettings:\n{0}", String.valueOf(this)); } } diff --git a/src/solaris/classes/sun/awt/X11/XBaseWindow.java b/src/solaris/classes/sun/awt/X11/XBaseWindow.java index 095f36c5e..3577b5f4e 100644 --- a/src/solaris/classes/sun/awt/X11/XBaseWindow.java +++ b/src/solaris/classes/sun/awt/X11/XBaseWindow.java @@ -824,7 +824,9 @@ public class XBaseWindow { * The active grab overrides activated automatic grab. */ public boolean grabInput() { - grabLog.log(Level.FINE, "Grab input on {0}", new Object[] {this}); + if (grabLog.isLoggable(Level.FINE)) { + grabLog.log(Level.FINE, "Grab input on {0}", new Object[] {String.valueOf(this)}); + } XToolkit.awtLock(); try { @@ -887,7 +889,10 @@ public class XBaseWindow { XToolkit.awtLock(); try { XBaseWindow grabWindow = XAwtState.getGrabWindow(); - grabLog.log(Level.FINE, "UnGrab input on {0}", new Object[] {grabWindow}); + if (grabLog.isLoggable(Level.FINE)) { + grabLog.log(Level.FINE, "UnGrab input on {0}", + new Object[] {String.valueOf(grabWindow)}); + } if (grabWindow != null) { grabWindow.ungrabInputImpl(); if (!XToolkit.getSunAwtDisableGrab()) { @@ -940,7 +945,7 @@ public class XBaseWindow { XPropertyCache.clearCache(window, XAtom.get(msg.get_atom())); } if (eventLog.isLoggable(Level.FINER)) { - eventLog.log(Level.FINER, "{0}", new Object[] {msg}); + eventLog.log(Level.FINER, "{0}", new Object[] {String.valueOf(msg)}); } } @@ -1021,8 +1026,10 @@ public class XBaseWindow { } public void handleConfigureNotifyEvent(XEvent xev) { XConfigureEvent xe = xev.get_xconfigure(); - insLog.log(Level.FINER, "Configure, {0}", - new Object[] {xe}); + 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(); diff --git a/src/solaris/classes/sun/awt/X11/XCheckboxMenuItemPeer.java b/src/solaris/classes/sun/awt/X11/XCheckboxMenuItemPeer.java index f2e1ef6f0..b54dfbd9e 100644 --- a/src/solaris/classes/sun/awt/X11/XCheckboxMenuItemPeer.java +++ b/src/solaris/classes/sun/awt/X11/XCheckboxMenuItemPeer.java @@ -29,8 +29,6 @@ import java.awt.*; import java.awt.peer.*; import java.awt.event.*; -import java.util.logging.*; - import java.lang.reflect.Field; import sun.awt.SunToolkit; @@ -42,8 +40,6 @@ class XCheckboxMenuItemPeer extends XMenuItemPeer implements CheckboxMenuItemPee * ************************************************/ - private static Logger log = Logger.getLogger("sun.awt.X11.XCheckboxMenuItemPeer"); - /* * CheckboxMenuItem's fields */ diff --git a/src/solaris/classes/sun/awt/X11/XComponentPeer.java b/src/solaris/classes/sun/awt/X11/XComponentPeer.java index cb842d4d6..606f6dee1 100644 --- a/src/solaris/classes/sun/awt/X11/XComponentPeer.java +++ b/src/solaris/classes/sun/awt/X11/XComponentPeer.java @@ -253,7 +253,9 @@ public class XComponentPeer extends XWindow implements ComponentPeer, DropTarget * Called when component receives focus */ public void focusGained(FocusEvent e) { - focusLog.log(Level.FINE, "{0}", new Object[] {e}); + if (focusLog.isLoggable(Level.FINE)) { + focusLog.log(Level.FINE, "{0}", new Object[] {String.valueOf(e)}); + } bHasFocus = true; } @@ -261,7 +263,9 @@ public class XComponentPeer extends XWindow implements ComponentPeer, DropTarget * Called when component loses focus */ public void focusLost(FocusEvent e) { - focusLog.log(Level.FINE, "{0}", new Object[] {e}); + if (focusLog.isLoggable(Level.FINE)) { + focusLog.log(Level.FINE, "{0}", new Object[] {String.valueOf(e)}); + } bHasFocus = false; } @@ -414,7 +418,10 @@ public class XComponentPeer extends XWindow implements ComponentPeer, DropTarget * @see java.awt.peer.ComponentPeer */ public void setEnabled(boolean value) { - enableLog.log(Level.FINE, "{0}ing {1}", new Object[] {(value?"Enabl":"Disabl"), this}); + if (enableLog.isLoggable(Level.FINE)) { + enableLog.log(Level.FINE, "{0}ing {1}", + new Object[] {(value?"Enabl":"Disabl"), String.valueOf(this)}); + } boolean repaintNeeded = (enabled != value); enabled = value; if (target instanceof Container) { @@ -1262,7 +1269,10 @@ public class XComponentPeer extends XWindow implements ComponentPeer, DropTarget * ButtonPress, ButtonRelease, KeyPress, KeyRelease, EnterNotify, LeaveNotify, MotionNotify */ protected boolean isEventDisabled(XEvent e) { - enableLog.log(Level.FINEST, "Component is {1}, checking for disabled event {0}", new Object[] {e, (isEnabled()?"enabled":"disable")}); + if (enableLog.isLoggable(Level.FINEST)) { + enableLog.log(Level.FINEST, "Component is {1}, checking for disabled event {0}", + new Object[] {String.valueOf(e), (isEnabled()?"enabled":"disable")}); + } if (!isEnabled()) { switch (e.get_type()) { case XConstants.ButtonPress: @@ -1272,7 +1282,9 @@ public class XComponentPeer extends XWindow implements ComponentPeer, DropTarget case XConstants.EnterNotify: case XConstants.LeaveNotify: case XConstants.MotionNotify: - enableLog.log(Level.FINER, "Event {0} is disable", new Object[] {e}); + if (enableLog.isLoggable(Level.FINER)) { + enableLog.log(Level.FINER, "Event {0} is disable", new Object[] {String.valueOf(e)}); + } return true; } } diff --git a/src/solaris/classes/sun/awt/X11/XContentWindow.java b/src/solaris/classes/sun/awt/X11/XContentWindow.java index 6a32fe9bd..93ddcae28 100644 --- a/src/solaris/classes/sun/awt/X11/XContentWindow.java +++ b/src/solaris/classes/sun/awt/X11/XContentWindow.java @@ -116,8 +116,10 @@ public final class XContentWindow extends XWindow { if (in != null) { newBounds.setLocation(-in.left, -in.top); } - if (insLog.isLoggable(Level.FINE)) insLog.log(Level.FINE, "Setting content bounds {0}, old bounds {1}", - new Object[] {newBounds, getBounds()}); + if (insLog.isLoggable(Level.FINE)) { + insLog.log(Level.FINE, "Setting content bounds {0}, old bounds {1}", + new Object[] {String.valueOf(newBounds), String.valueOf(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 diff --git a/src/solaris/classes/sun/awt/X11/XDecoratedPeer.java b/src/solaris/classes/sun/awt/X11/XDecoratedPeer.java index 417cd3b00..a067d7a71 100644 --- a/src/solaris/classes/sun/awt/X11/XDecoratedPeer.java +++ b/src/solaris/classes/sun/awt/X11/XDecoratedPeer.java @@ -79,7 +79,9 @@ abstract class XDecoratedPeer extends XWindowPeer { 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 }); + 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 @@ -265,7 +267,10 @@ abstract class XDecoratedPeer extends XWindowPeer { wm_set_insets = XWM.getInsetsFromProp(getWindow(), changedAtom); } - insLog.log(Level.FINER, "FRAME_EXTENTS: {0}", new Object[]{wm_set_insets}); + if (insLog.isLoggable(Level.FINER)) { + insLog.log(Level.FINER, "FRAME_EXTENTS: {0}", + new Object[]{String.valueOf(wm_set_insets)}); + } if (wm_set_insets != null) { wm_set_insets = copy(wm_set_insets); @@ -331,7 +336,10 @@ abstract class XDecoratedPeer extends XWindowPeer { // 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}); + 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)) { @@ -345,7 +353,9 @@ abstract class XDecoratedPeer extends XWindowPeer { correctWM = XWM.getWM().getInsets(this, xe.get_window(), xe.get_parent()); if (correctWM != null) { - insLog.log(Level.FINER, "correctWM {0}", new Object[] {correctWM}); + if (insLog.isLoggable(Level.FINE)) { + insLog.log(Level.FINER, "correctWM {0}", new Object[] {String.valueOf(correctWM)}); + } } else { insLog.log(Level.FINER, "correctWM insets are not available, waiting for configureNotify"); } @@ -368,7 +378,10 @@ abstract class XDecoratedPeer extends XWindowPeer { * initial insets were wrong (most likely they were). */ Insets correction = difference(correctWM, currentInsets); - insLog.log(Level.FINEST, "Corrention {0}", new Object[] {correction}); + if (insLog.isLoggable(Level.FINEST)) { + insLog.log(Level.FINEST, "Corrention {0}", + new Object[] {String.valueOf(correction)}); + } if (!isNull(correction)) { currentInsets = copy(correctWM); applyGuessedInsets(); @@ -453,7 +466,7 @@ abstract class XDecoratedPeer extends XWindowPeer { Insets in = copy(getRealInsets()); in.top += getMenuBarHeight(); if (insLog.isLoggable(Level.FINEST)) { - insLog.log(Level.FINEST, "Get insets returns {0}", new Object[] {in}); + insLog.log(Level.FINEST, "Get insets returns {0}", new Object[] {String.valueOf(in)}); } return in; } @@ -610,7 +623,7 @@ abstract class XDecoratedPeer extends XWindowPeer { break; } if (insLog.isLoggable(Level.FINE)) insLog.log(Level.FINE, "For the operation {0} new dimensions are {1}", - new Object[] {operationToString(operation), dims}); + new Object[] {operationToString(operation), String.valueOf(dims)}); reshape(dims, operation, userReshape); } @@ -640,7 +653,9 @@ abstract class XDecoratedPeer extends XWindowPeer { public void handleConfigureNotifyEvent(XEvent xev) { assert (SunToolkit.isAWTLockHeldByCurrentThread()); XConfigureEvent xe = xev.get_xconfigure(); - insLog.log(Level.FINE, "Configure notify {0}", new Object[] {xe}); + 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()) { @@ -732,7 +747,10 @@ abstract class XDecoratedPeer extends XWindowPeer { 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(Level.FINE)) { + log.log(Level.FINE, "New X location: {0}", + new Object[]{String.valueOf(xlocation)}); + } if (xlocation != null) { newLocation = xlocation; } @@ -749,8 +767,10 @@ abstract class XDecoratedPeer extends XWindowPeer { copy(currentInsets), true); - insLog.log(Level.FINER, "Insets are {0}, new dimensions {1}", - new Object[] {currentInsets, newDimensions}); + 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()); @@ -917,7 +937,7 @@ abstract class XDecoratedPeer extends XWindowPeer { Point location = target.getLocation(); if (insLog.isLoggable(Level.FINE)) insLog.log(Level.FINE, "getLocationOnScreen {0} not reparented: {1} ", - new Object[] {this, location}); + new Object[] {String.valueOf(this), String.valueOf(location)}); return location; } } finally { @@ -954,7 +974,10 @@ abstract class XDecoratedPeer extends XWindowPeer { } public void setVisible(boolean vis) { - log.log(Level.FINER, "Setting {0} to visible {1}", new Object[] {this, Boolean.valueOf(vis)}); + if (log.isLoggable(Level.FINE)) { + log.log(Level.FINER, "Setting {0} to visible {1}", + new Object[] {String.valueOf(this), Boolean.valueOf(vis)}); + } if (vis && !isVisible()) { XWM.setShellDecor(this); super.setVisible(vis); @@ -1005,7 +1028,9 @@ abstract class XDecoratedPeer extends XWindowPeer { } private void handleWmTakeFocus(XClientMessageEvent cl) { - focusLog.log(Level.FINE, "WM_TAKE_FOCUS on {0}", new Object[]{this}); + if (focusLog.isLoggable(Level.FINE)) { + focusLog.log(Level.FINE, "WM_TAKE_FOCUS on {0}", new Object[]{String.valueOf(this)}); + } requestWindowFocus(cl.get_data(1), true); } diff --git a/src/solaris/classes/sun/awt/X11/XDropTargetProtocol.java b/src/solaris/classes/sun/awt/X11/XDropTargetProtocol.java index 7a7c7c10e..13ff5bf4a 100644 --- a/src/solaris/classes/sun/awt/X11/XDropTargetProtocol.java +++ b/src/solaris/classes/sun/awt/X11/XDropTargetProtocol.java @@ -117,7 +117,7 @@ abstract class XDropTargetProtocol { EmbedderRegistryEntry entry = getEmbedderRegistryEntry(toplevel); if (logger.isLoggable(Level.FINEST)) { - logger.log(Level.FINEST, " entry={0}", new Object[] {entry}); + logger.log(Level.FINEST, " entry={0}", new Object[] {String.valueOf(entry)}); } // Window not registered as an embedder for this protocol. if (entry == null) { @@ -138,7 +138,8 @@ abstract class XDropTargetProtocol { long proxy = entry.getProxy(); if (logger.isLoggable(Level.FINEST)) { - logger.log(Level.FINEST, " proxy={0} toplevel={1}", new Object[] {proxy, toplevel}); + logger.log(Level.FINEST, " proxy={0} toplevel={1}", + new Object[] {String.valueOf(proxy), String.valueOf(toplevel)}); } if (proxy == 0) { proxy = toplevel; diff --git a/src/solaris/classes/sun/awt/X11/XFocusProxyWindow.java b/src/solaris/classes/sun/awt/X11/XFocusProxyWindow.java index 361ef87ee..bd30f6922 100644 --- a/src/solaris/classes/sun/awt/X11/XFocusProxyWindow.java +++ b/src/solaris/classes/sun/awt/X11/XFocusProxyWindow.java @@ -34,7 +34,6 @@ import java.util.logging.*; * and therefore X doesn't control focus after we have set it to proxy. */ public class XFocusProxyWindow extends XBaseWindow { - private static final Logger focusLog = Logger.getLogger("sun.awt.X11.focus.XFocusProxyWindow"); XWindowPeer owner; public XFocusProxyWindow(XWindowPeer owner) { diff --git a/src/solaris/classes/sun/awt/X11/XFramePeer.java b/src/solaris/classes/sun/awt/X11/XFramePeer.java index 22cb163eb..b1e422326 100644 --- a/src/solaris/classes/sun/awt/X11/XFramePeer.java +++ b/src/solaris/classes/sun/awt/X11/XFramePeer.java @@ -283,7 +283,9 @@ class XFramePeer extends XDecoratedPeer implements FramePeer { super.handlePropertyNotify(xev); XPropertyEvent ev = xev.get_xproperty(); - log.log(Level.FINER, "Property change {0}", new Object[] {ev}); + if (log.isLoggable(Level.FINER)) { + log.log(Level.FINER, "Property change {0}", new Object[] {String.valueOf(ev)}); + } /* * Let's see if this is a window state protocol message, and * if it is - decode a new state in terms of java constants. diff --git a/src/solaris/classes/sun/awt/X11/XIconWindow.java b/src/solaris/classes/sun/awt/X11/XIconWindow.java index a6211a0e0..e9643c915 100644 --- a/src/solaris/classes/sun/awt/X11/XIconWindow.java +++ b/src/solaris/classes/sun/awt/X11/XIconWindow.java @@ -75,7 +75,7 @@ public class XIconWindow extends XBaseWindow { XIconSize[] res = new XIconSize[count]; for (int i = 0; i < count; i++, sizes_ptr += XIconSize.getSize()) { res[i] = new XIconSize(sizes_ptr); - log.log(Level.FINEST, "sizes_ptr[{1}] = {0}", new Object[] {res[i], Integer.valueOf(i)}); + log.log(Level.FINEST, "sizes_ptr[{1}] = {0}", new Object[] {String.valueOf(res[i]), Integer.valueOf(i)}); } return res; } finally { @@ -92,7 +92,10 @@ public class XIconWindow extends XBaseWindow { } XIconSize[] sizeList = getIconSizes(); - log.log(Level.FINEST, "Icon sizes: {0}", new Object[] {sizeList}); + + if (log.isLoggable(Level.FINEST)) { + log.log(Level.FINEST, "Icon sizes: {0}", new Object[] {String.valueOf(sizeList)}); + } if (sizeList == null) { // No icon sizes so we simply fall back to 16x16 return new Dimension(16, 16); @@ -444,7 +447,9 @@ public class XIconWindow extends XBaseWindow { } Dimension iconSize = getIconSize(width, height); if (iconSize != null) { - log.log(Level.FINEST, "Icon size: {0}", iconSize); + if (log.isLoggable(Level.FINEST)) { + log.log(Level.FINEST, "Icon size: {0}", String.valueOf(iconSize)); + } iconWidth = iconSize.width; iconHeight = iconSize.height; } else { diff --git a/src/solaris/classes/sun/awt/X11/XInputMethod.java b/src/solaris/classes/sun/awt/X11/XInputMethod.java index 86df2073d..756c0ae12 100644 --- a/src/solaris/classes/sun/awt/X11/XInputMethod.java +++ b/src/solaris/classes/sun/awt/X11/XInputMethod.java @@ -108,7 +108,10 @@ public class XInputMethod extends X11InputMethod { client = getParent(client); peer = (XComponentPeer)XToolkit.targetToPeer(client); } - log.log(Level.FINE, "Peer is {0}, client is {1}", new Object[] {peer, client}); + if (log.isLoggable(Level.FINE)) { + log.log(Level.FINE, "Peer is {0}, client is {1}", + new Object[] {String.valueOf(peer), String.valueOf(client)}); + } if (peer != null) return peer; diff --git a/src/solaris/classes/sun/awt/X11/XMenuItemPeer.java b/src/solaris/classes/sun/awt/X11/XMenuItemPeer.java index ec80cebce..99e8d3fca 100644 --- a/src/solaris/classes/sun/awt/X11/XMenuItemPeer.java +++ b/src/solaris/classes/sun/awt/X11/XMenuItemPeer.java @@ -43,8 +43,6 @@ public class XMenuItemPeer implements MenuItemPeer { * ************************************************/ - private static Logger log = Logger.getLogger("sun.awt.X11.XMenuItemPeer"); - /* * Primary members */ diff --git a/src/solaris/classes/sun/awt/X11/XNETProtocol.java b/src/solaris/classes/sun/awt/X11/XNETProtocol.java index 1bc8829d9..02a570837 100644 --- a/src/solaris/classes/sun/awt/X11/XNETProtocol.java +++ b/src/solaris/classes/sun/awt/X11/XNETProtocol.java @@ -54,7 +54,11 @@ final class XNETProtocol extends XProtocol implements XStateProtocol, XLayerProt private void setInitialState(XWindowPeer window, int state) { XAtomList old_state = window.getNETWMState(); - log.log(Level.FINE, "Current state of the window {0} is {1}", new Object[] {window, old_state}); + if (log.isLoggable(Level.FINE)) { + log.log(Level.FINE, "Current state of the window {0} is {1}", + new Object[] {String.valueOf(window), + String.valueOf(old_state)}); + } if ((state & Frame.MAXIMIZED_VERT) != 0) { old_state.add(XA_NET_WM_STATE_MAXIMIZED_VERT); } else { @@ -65,7 +69,10 @@ final class XNETProtocol extends XProtocol implements XStateProtocol, XLayerProt } else { old_state.remove(XA_NET_WM_STATE_MAXIMIZED_HORZ); } - log.log(Level.FINE, "Setting initial state of the window {0} to {1}", new Object[] {window, old_state}); + if (log.isLoggable(Level.FINE)) { + log.log(Level.FINE, "Setting initial state of the window {0} to {1}", + new Object[] {String.valueOf(window), String.valueOf(old_state)}); + } window.setNETWMState(old_state); } @@ -180,7 +187,11 @@ final class XNETProtocol extends XProtocol implements XStateProtocol, XLayerProt req.set_data(1, state.getAtom()); // Fix for 6735584: req.data[2] must be set to 0 when only one property is changed req.set_data(2, 0); - log.log(Level.FINE, "Setting _NET_STATE atom {0} on {1} for {2}", new Object[] {state, window, Boolean.valueOf(isAdd)}); + if (log.isLoggable(Level.FINE)) { + log.log(Level.FINE, "Setting _NET_STATE atom {0} on {1} for {2}", + new Object[] {String.valueOf(state), String.valueOf(window), + Boolean.valueOf(isAdd)}); + } XToolkit.awtLock(); try { XlibWrapper.XSendEvent(XToolkit.getDisplay(), @@ -212,13 +223,19 @@ final class XNETProtocol extends XProtocol implements XStateProtocol, XLayerProt requestState(window, state, set); } else { XAtomList net_wm_state = window.getNETWMState(); - log.log(Level.FINE, "Current state on {0} is {1}", new Object[] {window, net_wm_state}); + if (log.isLoggable(Level.FINE)) { + log.log(Level.FINE, "Current state on {0} is {1}", + new Object[] {String.valueOf(window), net_wm_state}); + } if (!set) { net_wm_state.remove(state); } else { net_wm_state.add(state); } - log.log(Level.FINE, "Setting states on {0} to {1}", new Object[] {window, net_wm_state}); + if (log.isLoggable(Level.FINE)) { + log.log(Level.FINE, "Setting states on {0} to {1}", + new Object[] {String.valueOf(window), net_wm_state}); + } window.setNETWMState(net_wm_state); } XToolkit.XSync(); diff --git a/src/solaris/classes/sun/awt/X11/XProtocol.java b/src/solaris/classes/sun/awt/X11/XProtocol.java index 328f1a887..9fe1d0295 100644 --- a/src/solaris/classes/sun/awt/X11/XProtocol.java +++ b/src/solaris/classes/sun/awt/X11/XProtocol.java @@ -54,7 +54,11 @@ class XProtocol { } finally { if (firstCheck) { firstCheck = false; - log.log(Level.FINE, "{0}:{1} supports {2}", new Object[] {this, listName, protocols}); + if (log.isLoggable(Level.FINE)) { + log.log(Level.FINE, "{0}:{1} supports {2}", + new Object[] {String.valueOf(this), String.valueOf(listName), + String.valueOf(protocols)}); + } } } } diff --git a/src/solaris/classes/sun/awt/X11/XQueryTree.java b/src/solaris/classes/sun/awt/X11/XQueryTree.java index eaace18e9..e3e4901a4 100644 --- a/src/solaris/classes/sun/awt/X11/XQueryTree.java +++ b/src/solaris/classes/sun/awt/X11/XQueryTree.java @@ -32,7 +32,6 @@ import java.util.logging.*; public class XQueryTree { private static Unsafe unsafe = XlibWrapper.unsafe; - private static final Logger log = Logger.getLogger("sun.awt.X11.XQueryTree"); private boolean __executed = false; long _w; long root_ptr = unsafe.allocateMemory(Native.getLongSize()); diff --git a/src/solaris/classes/sun/awt/X11/XToolkit.java b/src/solaris/classes/sun/awt/X11/XToolkit.java index 14839c7b6..cba955ad1 100644 --- a/src/solaris/classes/sun/awt/X11/XToolkit.java +++ b/src/solaris/classes/sun/awt/X11/XToolkit.java @@ -624,7 +624,7 @@ public final class XToolkit extends UNIXToolkit implements Runnable { } if (eventLog.isLoggable(Level.FINER)) { - eventLog.log(Level.FINER, "{0}", ev); + eventLog.log(Level.FINER, "{0}", String.valueOf(ev)); } // Check if input method consumes the event @@ -1837,8 +1837,10 @@ public final class XToolkit extends UNIXToolkit implements Runnable { if (timeoutTaskLog.isLoggable(Level.FINER)) { timeoutTaskLog.log(Level.FINER, "XToolkit.schedule(): current time={0}" + "; interval={1}" + - "; task being added={2}" + "; tasks before addition={3}", new Object[] { - Long.valueOf(System.currentTimeMillis()), Long.valueOf(interval), task, timeoutTasks}); + "; task being added={2}" + "; tasks before addition={3}", + new Object[] {Long.valueOf(System.currentTimeMillis()), + Long.valueOf(interval), String.valueOf(task), + String.valueOf(timeoutTasks)}); } if (timeoutTasks == null) { @@ -1883,7 +1885,8 @@ public final class XToolkit extends UNIXToolkit implements Runnable { private static void callTimeoutTasks() { if (timeoutTaskLog.isLoggable(Level.FINER)) { timeoutTaskLog.log(Level.FINER, "XToolkit.callTimeoutTasks(): current time={0}" + - "; tasks={1}", new Object[] {Long.valueOf(System.currentTimeMillis()), timeoutTasks}); + "; tasks={1}", + new Object[] {Long.valueOf(System.currentTimeMillis()), String.valueOf(timeoutTasks)}); } if (timeoutTasks == null || timeoutTasks.isEmpty()) { @@ -1901,7 +1904,8 @@ public final class XToolkit extends UNIXToolkit implements Runnable { if (timeoutTaskLog.isLoggable(Level.FINER)) { timeoutTaskLog.log(Level.FINER, "XToolkit.callTimeoutTasks(): current time={0}" + - "; about to run task={1}", new Object[] {Long.valueOf(currentTime), task}); + "; about to run task={1}", + new Object[] {Long.valueOf(currentTime), String.valueOf(task)}); } try { @@ -2358,7 +2362,10 @@ public final class XToolkit extends UNIXToolkit implements Runnable { // Wait for selection notify for oops on win long event_number = getEventNumber(); XAtom atom = XAtom.get("WM_S0"); - eventLog.log(Level.FINER, "WM_S0 selection owner {0}", new Object[] {XlibWrapper.XGetSelectionOwner(getDisplay(), atom.getAtom())}); + if (eventLog.isLoggable(Level.FINER)) { + eventLog.log(Level.FINER, "WM_S0 selection owner {0}", + new Object[] {String.valueOf(XlibWrapper.XGetSelectionOwner(getDisplay(), atom.getAtom()))}); + } XlibWrapper.XConvertSelection(getDisplay(), atom.getAtom(), XAtom.get("VERSION").getAtom(), oops.getAtom(), win.getWindow(), XConstants.CurrentTime); diff --git a/src/solaris/classes/sun/awt/X11/XTrayIconPeer.java b/src/solaris/classes/sun/awt/X11/XTrayIconPeer.java index b1243abac..f3b6310c0 100644 --- a/src/solaris/classes/sun/awt/X11/XTrayIconPeer.java +++ b/src/solaris/classes/sun/awt/X11/XTrayIconPeer.java @@ -129,14 +129,17 @@ public class XTrayIconPeer implements TrayIconPeer, // If both the height and the width differ from the fixed size then WM // must level at least one side to the fixed size. For some reason it may take // a few hops (even after reparenting) and we have to skip the intermediate ones. - ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Skipping as intermediate resizing.", - XTrayIconPeer.this); + if (ctrLog.isLoggable(Level.FINE)) { + ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Skipping as intermediate resizing.", + String.valueOf(XTrayIconPeer.this)); + } return; } else if (ce.get_height() > TRAY_ICON_HEIGHT) { - - ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Centering by \"Y\".", - XTrayIconPeer.this); + if (ctrLog.isLoggable(Level.FINE)) { + ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Centering by \"Y\".", + String.valueOf(XTrayIconPeer.this)); + } XlibWrapper.XMoveResizeWindow(XToolkit.getDisplay(), eframeParentID, ce.get_x(), @@ -147,9 +150,10 @@ public class XTrayIconPeer implements TrayIconPeer, ex_width = 0; } else if (ce.get_width() > TRAY_ICON_WIDTH) { - - ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Centering by \"X\".", - XTrayIconPeer.this); + if (ctrLog.isLoggable(Level.FINE)) { + ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Centering by \"X\".", + String.valueOf(XTrayIconPeer.this)); + } XlibWrapper.XMoveResizeWindow(XToolkit.getDisplay(), eframeParentID, ce.get_x()+ce.get_width()/2 - TRAY_ICON_WIDTH/2, @@ -165,25 +169,32 @@ public class XTrayIconPeer implements TrayIconPeer, // In this case the parent window also lose centering. We have to restore it. if (ex_height != 0) { - - ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Move detected. Centering by \"Y\".", - XTrayIconPeer.this); + if (ctrLog.isLoggable(Level.FINE)) { + ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}." + + " Move detected. Centering by \"Y\".", + String.valueOf(XTrayIconPeer.this)); + } XlibWrapper.XMoveWindow(XToolkit.getDisplay(), eframeParentID, ce.get_x(), ce.get_y() + ex_height/2 - TRAY_ICON_HEIGHT/2); } else if (ex_width != 0) { - - ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Move detected. Centering by \"X\".", - XTrayIconPeer.this); + if (ctrLog.isLoggable(Level.FINE)) { + ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}." + + "Move detected. Centering by \"X\".", + String.valueOf(XTrayIconPeer.this)); + } XlibWrapper.XMoveWindow(XToolkit.getDisplay(), eframeParentID, ce.get_x() + ex_width/2 - TRAY_ICON_WIDTH/2, ce.get_y()); } else { - ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}. Move detected. Skipping.", - XTrayIconPeer.this); + if (ctrLog.isLoggable(Level.FINE)) { + ctrLog.log(Level.FINE, "ConfigureNotify on parent of {0}." + + "Move detected. Skipping.", + String.valueOf(XTrayIconPeer.this)); + } } } old_x = ce.get_x(); diff --git a/src/solaris/classes/sun/awt/X11/XWM.java b/src/solaris/classes/sun/awt/X11/XWM.java index 4d49dee60..74aa3119b 100644 --- a/src/solaris/classes/sun/awt/X11/XWM.java +++ b/src/solaris/classes/sun/awt/X11/XWM.java @@ -401,7 +401,10 @@ final class XWM static boolean isCDE() { if (!XA_DT_SM_WINDOW_INFO.isInterned()) { - log.log(Level.FINER, "{0} is not interned", new Object[] {XA_DT_SM_WINDOW_INFO}); + if (log.isLoggable(Level.FINER)) { + log.log(Level.FINER, "{0} is not interned", + new Object[] {String.valueOf(XA_DT_SM_WINDOW_INFO)}); + } return false; } @@ -432,7 +435,10 @@ final class XWM /* Now check that this window has _DT_SM_STATE_INFO (ignore contents) */ if (!XA_DT_SM_STATE_INFO.isInterned()) { - log.log(Level.FINER, "{0} is not interned", new Object[] {XA_DT_SM_STATE_INFO}); + if (log.isLoggable(Level.FINER)) { + log.log(Level.FINER, "{0} is not interned", + new Object[] {String.valueOf(XA_DT_SM_STATE_INFO)}); + } return false; } WindowPropertyGetter getter2 = @@ -596,7 +602,10 @@ final class XWM */ if (!XA_ICEWM_WINOPTHINT.isInterned()) { - log.log(Level.FINER, "{0} is not interned", new Object[] {XA_ICEWM_WINOPTHINT}); + if (log.isLoggable(Level.FINER)) { + log.log(Level.FINER, "{0} is not interned", + String.valueOf(XA_ICEWM_WINOPTHINT)); + } return false; } @@ -629,7 +638,10 @@ final class XWM */ static boolean isIceWM() { if (!XA_ICEWM_WINOPTHINT.isInterned()) { - log.log(Level.FINER, "{0} is not interned", new Object[] {XA_ICEWM_WINOPTHINT}); + if (log.isLoggable(Level.FINER)) { + log.log(Level.FINER, "{0} is not interned", + new Object[] {String.valueOf(XA_ICEWM_WINOPTHINT)}); + } return false; } @@ -1354,7 +1366,9 @@ final class XWM XNETProtocol net_protocol = getWM().getNETProtocol(); if (net_protocol != null && net_protocol.active()) { Insets insets = getInsetsFromProp(window, XA_NET_FRAME_EXTENTS); - insLog.log(Level.FINE, "_NET_FRAME_EXTENTS: {0}", insets); + if (insLog.isLoggable(Level.FINE)) { + insLog.log(Level.FINE, "_NET_FRAME_EXTENTS: {0}", String.valueOf(insets)); + } if (insets != null) { return insets; @@ -1495,7 +1509,10 @@ final class XWM * [mwm, e!, kwin, fvwm2 ... ] */ Insets correctWM = XWM.getInsetsFromExtents(window); - insLog.log(Level.FINER, "Got insets from property: {0}", correctWM); + if (insLog.isLoggable(Level.FINER)) { + insLog.log(Level.FINER, "Got insets from property: {0}", + String.valueOf(correctWM)); + } if (correctWM == null) { correctWM = new Insets(0,0,0,0); @@ -1556,7 +1573,10 @@ final class XWM } case XWM.OTHER_WM: default: { /* this is very similar to the E! case above */ - insLog.log(Level.FINEST, "Getting correct insets for OTHER_WM/default, parent: {0}", parent); + if (insLog.isLoggable(Level.FINEST)) { + insLog.log(Level.FINEST, "Getting correct insets for OTHER_WM/default, parent: {0}", + String.valueOf(parent)); + } syncTopLevelPos(parent, lwinAttr); int status = XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(), window, lwinAttr.pData); @@ -1583,8 +1603,11 @@ final class XWM && lwinAttr.get_width()+2*lwinAttr.get_border_width() == pattr.get_width() && lwinAttr.get_height()+2*lwinAttr.get_border_width() == pattr.get_height()) { - insLog.log(Level.FINEST, "Double reparenting detected, pattr({2})={0}, lwinAttr({3})={1}", - new Object[] {lwinAttr, pattr, parent, window}); + if (insLog.isLoggable(Level.FINEST)) { + insLog.log(Level.FINEST, "Double reparenting detected, pattr({2})={0}, lwinAttr({3})={1}", + new Object[] {String.valueOf(lwinAttr), String.valueOf(pattr), + String.valueOf(parent), String.valueOf(window)}); + } lwinAttr.set_x(pattr.get_x()); lwinAttr.set_y(pattr.get_y()); lwinAttr.set_border_width(lwinAttr.get_border_width()+pattr.get_border_width()); @@ -1611,8 +1634,11 @@ final class XWM * widths and inner/outer distinction, so for the time * being, just ignore it. */ - insLog.log(Level.FINEST, "Attrs before calculation: pattr({2})={0}, lwinAttr({3})={1}", - new Object[] {lwinAttr, pattr, parent, window}); + if (insLog.isLoggable(Level.FINEST)) { + insLog.log(Level.FINEST, "Attrs before calculation: pattr({2})={0}, lwinAttr({3})={1}", + new Object[] {String.valueOf(lwinAttr), String.valueOf(pattr), + String.valueOf(parent), String.valueOf(window)}); + } correctWM = new Insets(lwinAttr.get_y() + lwinAttr.get_border_width(), lwinAttr.get_x() + lwinAttr.get_border_width(), pattr.get_height() - (lwinAttr.get_y() + lwinAttr.get_height() + 2*lwinAttr.get_border_width()), diff --git a/src/solaris/classes/sun/awt/X11/XWindow.java b/src/solaris/classes/sun/awt/X11/XWindow.java index f1c3c675b..4f7d56896 100644 --- a/src/solaris/classes/sun/awt/X11/XWindow.java +++ b/src/solaris/classes/sun/awt/X11/XWindow.java @@ -997,8 +997,10 @@ public class XWindow extends XBaseWindow implements X11ComponentPeer { Rectangle oldBounds = getBounds(); super.handleConfigureNotifyEvent(xev); - insLog.log(Level.FINER, "Configure, {0}, event disabled: {1}", - new Object[] {xev.get_xconfigure(), isEventDisabled(xev)}); + if (insLog.isLoggable(Level.FINER)) { + insLog.log(Level.FINER, "Configure, {0}, event disabled: {1}", + new Object[] {String.valueOf(xev.get_xconfigure()), isEventDisabled(xev)}); + } if (isEventDisabled(xev)) { return; } @@ -1017,7 +1019,9 @@ public class XWindow extends XBaseWindow implements X11ComponentPeer { public void handleMapNotifyEvent(XEvent xev) { super.handleMapNotifyEvent(xev); - log.log(Level.FINE, "Mapped {0}", new Object[] {this}); + if (log.isLoggable(Level.FINE)) { + log.log(Level.FINE, "Mapped {0}", new Object[] {String.valueOf(this)}); + } if (isEventDisabled(xev)) { return; } @@ -1333,10 +1337,16 @@ public class XWindow extends XBaseWindow implements X11ComponentPeer { void updateSizeHints(int x, int y, int width, int height) { long flags = XUtilConstants.PSize | (isLocationByPlatform() ? 0 : (XUtilConstants.PPosition | XUtilConstants.USPosition)); if (!isResizable()) { - log.log(Level.FINER, "Window {0} is not resizable", new Object[] {this}); + if (log.isLoggable(Level.FINER)) { + log.log(Level.FINER, "Window {0} is not resizable", + new Object[] {String.valueOf(this)}); + } flags |= XUtilConstants.PMinSize | XUtilConstants.PMaxSize; } else { - log.log(Level.FINER, "Window {0} is resizable", new Object[] {this}); + if (keyEventLog.isLoggable(Level.FINER)) { + log.log(Level.FINER, "Window {0} is resizable", + new Object[] {String.valueOf(this)}); + } } setSizeHints(flags, x, y, width, height); } @@ -1344,10 +1354,16 @@ public class XWindow extends XBaseWindow implements X11ComponentPeer { void updateSizeHints(int x, int y) { long flags = isLocationByPlatform() ? 0 : (XUtilConstants.PPosition | XUtilConstants.USPosition); if (!isResizable()) { - log.log(Level.FINER, "Window {0} is not resizable", new Object[] {this}); + if (log.isLoggable(Level.FINER)) { + log.log(Level.FINER, "Window {0} is not resizable", + new Object[] {String.valueOf(this)}); + } flags |= XUtilConstants.PMinSize | XUtilConstants.PMaxSize | XUtilConstants.PSize; } else { - log.log(Level.FINER, "Window {0} is resizable", new Object[] {this}); + if (log.isLoggable(Level.FINER)) { + log.log(Level.FINER, "Window {0} is resizable", + new Object[] {String.valueOf(this)}); + } } setSizeHints(flags, x, y, width, height); } diff --git a/src/solaris/classes/sun/awt/X11/XWindowPeer.java b/src/solaris/classes/sun/awt/X11/XWindowPeer.java index b1646413b..0c3a12a8f 100644 --- a/src/solaris/classes/sun/awt/X11/XWindowPeer.java +++ b/src/solaris/classes/sun/awt/X11/XWindowPeer.java @@ -354,7 +354,7 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, if (iconLog.isLoggable(Level.FINEST)) { iconLog.log(Level.FINEST, ">>> Sizes of icon images:"); for (Iterator i = icons.iterator(); i.hasNext(); ) { - iconLog.log(Level.FINEST, " {0}", i.next()); + iconLog.log(Level.FINEST, " {0}", String.valueOf(i.next())); } } } @@ -769,7 +769,9 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, public void handleFocusEvent(XEvent xev) { XFocusChangeEvent xfe = xev.get_xfocus(); FocusEvent fe; - focusLog.log(Level.FINE, "{0}", new Object[] {xfe}); + if (focusLog.isLoggable(Level.FINE)) { + focusLog.log(Level.FINE, "{0}", new Object[] {String.valueOf(xfe)}); + } if (isEventDisabled(xev)) { return; } @@ -1388,7 +1390,10 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, synchronized(getStateLock()) { XDialogPeer blockerPeer = (XDialogPeer) ComponentAccessor.getPeer(d); if (blocked) { - log.log(Level.FINE, "{0} is blocked by {1}", new Object[] { this, blockerPeer}); + if (log.isLoggable(Level.FINE)) { + log.log(Level.FINE, "{0} is blocked by {1}", + new Object[] { String.valueOf(this), String.valueOf(blockerPeer)}); + } modalBlocker = d; if (isReparented() || XWM.isNonReparentingWM()) { @@ -1866,7 +1871,8 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, XCrossingEvent xce = xev.get_xcrossing(); if (grabLog.isLoggable(Level.FINE)) { grabLog.log(Level.FINE, "{0}, when grabbed {1}, contains {2}", - new Object[] {xce, isGrabbed(), containsGlobal(xce.get_x_root(), xce.get_y_root())}); + new Object[] {String.valueOf(xce), isGrabbed(), + containsGlobal(xce.get_x_root(), xce.get_y_root())}); } if (isGrabbed()) { // When window is grabbed, all events are dispatched to @@ -1877,7 +1883,10 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, // since it generates MOUSE_ENTERED/MOUSE_EXITED for frame and dialog. // (fix for 6390326) XBaseWindow target = XToolkit.windowToXWindow(xce.get_window()); - grabLog.log(Level.FINER, " - Grab event target {0}", new Object[] {target}); + if (grabLog.isLoggable(Level.FINER)) { + grabLog.log(Level.FINER, " - Grab event target {0}", + new Object[] {String.valueOf(target)}); + } if (target != null && target != this) { target.dispatchEvent(xev); return; @@ -1890,7 +1899,8 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, XMotionEvent xme = xev.get_xmotion(); if (grabLog.isLoggable(Level.FINE)) { grabLog.log(Level.FINER, "{0}, when grabbed {1}, contains {2}", - new Object[] {xme, isGrabbed(), containsGlobal(xme.get_x_root(), xme.get_y_root())}); + new Object[] {String.valueOf(xme), isGrabbed(), + containsGlobal(xme.get_x_root(), xme.get_y_root())}); } if (isGrabbed()) { boolean dragging = false; @@ -1919,7 +1929,10 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, xme.set_x(localCoord.x); xme.set_y(localCoord.y); } - grabLog.log(Level.FINER, " - Grab event target {0}", new Object[] {target}); + if (grabLog.isLoggable(Level.FINER)) { + grabLog.log(Level.FINER, " - Grab event target {0}", + new Object[] {String.valueOf(target)}); + } if (target != null) { if (target != getContentXWindow() && target != this) { target.dispatchEvent(xev); @@ -1953,7 +1966,9 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, } if (grabLog.isLoggable(Level.FINE)) { grabLog.log(Level.FINE, "{0}, when grabbed {1}, contains {2} ({3}, {4}, {5}x{6})", - new Object[] {xbe, isGrabbed(), containsGlobal(xbe.get_x_root(), xbe.get_y_root()), getAbsoluteX(), getAbsoluteY(), getWidth(), getHeight()}); + new Object[] {String.valueOf(xbe), isGrabbed(), + containsGlobal(xbe.get_x_root(), xbe.get_y_root()), + getAbsoluteX(), getAbsoluteY(), getWidth(), getHeight()}); } if (isGrabbed()) { // When window is grabbed, all events are dispatched to @@ -1962,7 +1977,10 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, // translation) XBaseWindow target = XToolkit.windowToXWindow(xbe.get_window()); try { - grabLog.log(Level.FINER, " - Grab event target {0} (press target {1})", new Object[] {target, pressTarget}); + if (grabLog.isLoggable(Level.FINER)) { + grabLog.log(Level.FINER, " - Grab event target {0} (press target {1})", + new Object[] {String.valueOf(target), String.valueOf(pressTarget)}); + } if (xbe.get_type() == XConstants.ButtonPress && xbe.get_button() == XConstants.buttons[0]) { @@ -1995,7 +2013,10 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, // Outside this toplevel hierarchy // According to the specification of UngrabEvent, post it // when press occurs outside of the window and not on its owned windows - grabLog.log(Level.FINE, "Generating UngrabEvent on {0} because not inside of shell", this); + if (grabLog.isLoggable(Level.FINE)) { + grabLog.log(Level.FINE, "Generating UngrabEvent on {0} because not inside of shell", + String.valueOf(this)); + } postEventToEventQueue(new sun.awt.UngrabEvent(getEventSource())); return; } @@ -2013,18 +2034,27 @@ class XWindowPeer extends XPanelPeer implements WindowPeer, // toplevel == null - outside of // hierarchy, toplevel is Dialog - should // send ungrab (but shouldn't for Window) - grabLog.log(Level.FINE, "Generating UngrabEvent on {0} because hierarchy ended", this); + if (grabLog.isLoggable(Level.FINE)) { + grabLog.log(Level.FINE, "Generating UngrabEvent on {0} because hierarchy ended", + String.valueOf(this)); + } postEventToEventQueue(new sun.awt.UngrabEvent(getEventSource())); } } else { // toplevel is null - outside of hierarchy - grabLog.log(Level.FINE, "Generating UngrabEvent on {0} because toplevel is null", this); + if (grabLog.isLoggable(Level.FINE)) { + grabLog.log(Level.FINE, "Generating UngrabEvent on {0} because toplevel is null", + String.valueOf(this)); + } postEventToEventQueue(new sun.awt.UngrabEvent(getEventSource())); return; } } else { // target doesn't map to XAWT window - outside of hierarchy - grabLog.log(Level.FINE, "Generating UngrabEvent on because target is null {0}", this); + if (grabLog.isLoggable(Level.FINE)) { + grabLog.log(Level.FINE, "Generating UngrabEvent on because target is null {0}", + String.valueOf(this)); + } postEventToEventQueue(new sun.awt.UngrabEvent(getEventSource())); return; } diff --git a/src/windows/classes/sun/awt/windows/WMenuItemPeer.java b/src/windows/classes/sun/awt/windows/WMenuItemPeer.java index e15232688..7080de47a 100644 --- a/src/windows/classes/sun/awt/windows/WMenuItemPeer.java +++ b/src/windows/classes/sun/awt/windows/WMenuItemPeer.java @@ -35,7 +35,7 @@ import java.util.logging.Logger; import java.util.logging.Level; class WMenuItemPeer extends WObjectPeer implements MenuItemPeer { - private static final Logger log = Logger.getLogger("sun.awt.WMenuItemPeer"); + private static final Logger log = Logger.getLogger("sun.awt.windows.WMenuItemPeer"); static { initIDs(); diff --git a/src/windows/classes/sun/awt/windows/WPanelPeer.java b/src/windows/classes/sun/awt/windows/WPanelPeer.java index 3b4af6dd1..4f38013f3 100644 --- a/src/windows/classes/sun/awt/windows/WPanelPeer.java +++ b/src/windows/classes/sun/awt/windows/WPanelPeer.java @@ -34,7 +34,6 @@ import java.util.logging.*; class WPanelPeer extends WCanvasPeer implements PanelPeer { - private static final Logger log = Logger.getLogger("sun.awt.windows.WPanelPeer"); // ComponentPeer overrides public void paint(Graphics g) { -- GitLab