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

equal deleted inserted replaced

-:487e1aa949c4
+:ef327bd847c0
 import java.lang.ref.WeakReference;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.logging.Level;
+import sun.util.logging.PlatformLogger;
-import java.util.logging.Logger;
 import sun.awt.*;
 import sun.awt.image.PixelConverter;
 import sun.java2d.SunGraphics2D;
 import sun.java2d.SurfaceData;
 public class XWindow extends XBaseWindow implements X11ComponentPeer {
-private static Logger log = Logger.getLogger("sun.awt.X11.XWindow");
+private static PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XWindow");
-private static Logger insLog = Logger.getLogger("sun.awt.X11.insets.XWindow");
+private static PlatformLogger insLog = PlatformLogger.getLogger("sun.awt.X11.insets.XWindow");
-private static Logger eventLog = Logger.getLogger("sun.awt.X11.event.XWindow");
+private static PlatformLogger eventLog = PlatformLogger.getLogger("sun.awt.X11.event.XWindow");
-private static final Logger focusLog = Logger.getLogger("sun.awt.X11.focus.XWindow");
+private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.X11.focus.XWindow");
-private static Logger keyEventLog = Logger.getLogger("sun.awt.X11.kye.XWindow");
+private static PlatformLogger keyEventLog = PlatformLogger.getLogger("sun.awt.X11.kye.XWindow");
 /* If a motion comes in while a multi-click is pending,
 * allow a smudge factor so that moving the mouse by a small
 * amount does not wipe out the multi-click state variables.
 */
 private final static int AWT_MULTICLICK_SMUDGE = 4;
 assert(false);
 }
 ((Component)e.getSource()).dispatchEvent(e);
 }
 }, PeerEvent.ULTIMATE_PRIORITY_EVENT);
-if (focusLog.isLoggable(Level.FINER) && (e instanceof FocusEvent)) focusLog.finer("Sending " + e);
+if (focusLog.isLoggable(PlatformLogger.FINER) && (e instanceof FocusEvent)) focusLog.finer("Sending " + e);
 XToolkit.postEvent(XToolkit.targetToAppContext(e.getSource()), pe);
 }
 /*
 super.handleButtonPressRelease(xev);
 XButtonEvent xbe = xev.get_xbutton();
 if (isEventDisabled(xev)) {
 return;
 }
-if (eventLog.isLoggable(Level.FINE)) eventLog.fine(xbe.toString());
+if (eventLog.isLoggable(PlatformLogger.FINE)) eventLog.fine(xbe.toString());
 long when;
 int modifiers;
 boolean popupTrigger = false;
 int button=0;
 boolean wheel_mouse = false;
 mouseButtonClickAllowed |= XConstants.buttonsMask[lbutton];
 XWindow lastWindow = (lastWindowRef != null) ? ((XWindow)lastWindowRef.get()):(null);
 /*
 multiclick checking
 */
-if (eventLog.isLoggable(Level.FINEST)) eventLog.finest("lastWindow = " + lastWindow + ", lastButton "
+if (eventLog.isLoggable(PlatformLogger.FINEST)) eventLog.finest("lastWindow = " + lastWindow + ", lastButton "
 + lastButton + ", lastTime " + lastTime + ", multiClickTime "
 + XToolkit.getMultiClickTime());
 if (lastWindow == this && lastButton == lbutton && (when - lastTime) < XToolkit.getMultiClickTime()) {
 clickCount++;
 } else {
 public void handleXCrossingEvent(XEvent xev) {
 super.handleXCrossingEvent(xev);
 XCrossingEvent xce = xev.get_xcrossing();
-if (eventLog.isLoggable(Level.FINEST)) eventLog.finest(xce.toString());
+if (eventLog.isLoggable(PlatformLogger.FINEST)) eventLog.finest(xce.toString());
 if (xce.get_type() == XConstants.EnterNotify) {
 enterNotify(xce.get_window());
 } else { // LeaveNotify:
 leaveNotify(xce.get_window());
 public void handleConfigureNotifyEvent(XEvent xev) {
 Rectangle oldBounds = getBounds();
 super.handleConfigureNotifyEvent(xev);
-insLog.log(Level.FINER, "Configure, {0}, event disabled: {1}",
+insLog.finer("Configure, {0}, event disabled: {1}",
-new Object[] {xev.get_xconfigure(), isEventDisabled(xev)});
+xev.get_xconfigure(), isEventDisabled(xev));
 if (isEventDisabled(xev)) {
 return;
 }
 //  if ( Check if it's a resize, a move, or a stacking order change )
 //  }
 }
 public void handleMapNotifyEvent(XEvent xev) {
 super.handleMapNotifyEvent(xev);
-log.log(Level.FINE, "Mapped {0}", new Object[] {this});
+log.fine("Mapped {0}", this);
 if (isEventDisabled(xev)) {
 return;
 }
 ComponentEvent ce;
 keyEventLog.fine("XXXXXXXXXXXXXX javakeycode will be most probably:0x"+ Integer.toHexString(XKeysym.getJavaKeycodeOnly(ev)));
 }
 public void handleKeyPress(XEvent xev) {
 super.handleKeyPress(xev);
 XKeyEvent ev = xev.get_xkey();
-if (eventLog.isLoggable(Level.FINE)) eventLog.fine(ev.toString());
+if (eventLog.isLoggable(PlatformLogger.FINE)) eventLog.fine(ev.toString());
 if (isEventDisabled(xev)) {
 return;
 }
 handleKeyPress(ev);
 }
 final void handleKeyPress(XKeyEvent ev) {
 long keysym[] = new long[2];
 int unicodeKey = 0;
 keysym[0] = XConstants.NoSymbol;
-if (keyEventLog.isLoggable(Level.FINE)) {
+if (keyEventLog.isLoggable(PlatformLogger.FINE)) {
 logIncomingKeyEvent( ev );
 }
 if ( //TODO check if there's an active input method instance
 // without calling a native method. Is it necessary though?
 haveCurrentX11InputMethodInstance()) {
 if (x11inputMethodLookupString(ev.pData, keysym)) {
-if (keyEventLog.isLoggable(Level.FINE)) {
+if (keyEventLog.isLoggable(PlatformLogger.FINE)) {
 keyEventLog.fine("--XWindow.java XIM did process event; return; dec keysym processed:"+(keysym[0])+
 "; hex keysym processed:"+Long.toHexString(keysym[0])
 );
 }
 return;
 }else {
 unicodeKey = keysymToUnicode( keysym[0], ev.get_state() );
-if (keyEventLog.isLoggable(Level.FINE)) {
+if (keyEventLog.isLoggable(PlatformLogger.FINE)) {
 keyEventLog.fine("--XWindow.java XIM did NOT process event, hex keysym:"+Long.toHexString(keysym[0])+"\n"+
 "                                         unicode key:"+Integer.toHexString((int)unicodeKey));
 }
 }
 }else  {
 // No input method instance found. For example, there's a Java Input Method.
 // Produce do-it-yourself keysym and perhaps unicode character.
 keysym[0] = xkeycodeToKeysym(ev);
 unicodeKey = keysymToUnicode( keysym[0], ev.get_state() );
-if (keyEventLog.isLoggable(Level.FINE)) {
+if (keyEventLog.isLoggable(PlatformLogger.FINE)) {
 keyEventLog.fine("--XWindow.java XIM is absent;             hex keysym:"+Long.toHexString(keysym[0])+"\n"+
 "                                         unicode key:"+Integer.toHexString((int)unicodeKey));
 }
 }
 // Keysym should be converted to Unicode, if possible and necessary,
 // Take the first keysym from a keysym array associated with the XKeyevent
 // and convert it to Unicode. Then, even if a Java keycode for the keystroke
 // is undefined, we still have a guess of what has been engraved on a keytop.
 int unicodeFromPrimaryKeysym = keysymToUnicode( xkeycodeToPrimaryKeysym(ev) ,0);
-if (keyEventLog.isLoggable(Level.FINE)) {
+if (keyEventLog.isLoggable(PlatformLogger.FINE)) {
 keyEventLog.fine(">>>Fire Event:"+
 (ev.get_type() == XConstants.KeyPress ? "KEY_PRESSED; " : "KEY_RELEASED; ")+
 "jkeycode:decimal="+jkc.getJavaKeycode()+
 ", hex=0x"+Integer.toHexString(jkc.getJavaKeycode())+"; "+
 " legacy jkeycode: decimal="+XKeysym.getLegacyJavaKeycodeOnly(ev)+
 }
 public void handleKeyRelease(XEvent xev) {
 super.handleKeyRelease(xev);
 XKeyEvent ev = xev.get_xkey();
-if (eventLog.isLoggable(Level.FINE)) eventLog.fine(ev.toString());
+if (eventLog.isLoggable(PlatformLogger.FINE)) eventLog.fine(ev.toString());
 if (isEventDisabled(xev)) {
 return;
 }
 handleKeyRelease(ev);
 }
 private void handleKeyRelease(XKeyEvent ev) {
 long keysym[] = new long[2];
 int unicodeKey = 0;
 keysym[0] = XConstants.NoSymbol;
-if (keyEventLog.isLoggable(Level.FINE)) {
+if (keyEventLog.isLoggable(PlatformLogger.FINE)) {
 logIncomingKeyEvent( ev );
 }
 // Keysym should be converted to Unicode, if possible and necessary,
 // and Java KeyEvent keycode should be calculated.
 // For release we should post released event.
 //
 XKeysym.Keysym2JavaKeycode jkc = XKeysym.getJavaKeycode(ev);
 if( jkc == null ) {
 jkc = new XKeysym.Keysym2JavaKeycode(java.awt.event.KeyEvent.VK_UNDEFINED, java.awt.event.KeyEvent.KEY_LOCATION_UNKNOWN);
 }
-if (keyEventLog.isLoggable(Level.FINE)) {
+if (keyEventLog.isLoggable(PlatformLogger.FINE)) {
 keyEventLog.fine(">>>Fire Event:"+
 (ev.get_type() == XConstants.KeyPress ? "KEY_PRESSED; " : "KEY_RELEASED; ")+
 "jkeycode:decimal="+jkc.getJavaKeycode()+
 ", hex=0x"+Integer.toHexString(jkc.getJavaKeycode())+"; "+
 " legacy jkeycode: decimal="+XKeysym.getLegacyJavaKeycodeOnly(ev)+
 }
 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});
+log.finer("Window {0} is not resizable", this);
 flags |= XUtilConstants.PMinSize | XUtilConstants.PMaxSize;
 } else {
-log.log(Level.FINER, "Window {0} is resizable", new Object[] {this});
+log.finer("Window {0} is resizable", this);
 }
 setSizeHints(flags, x, y, width, height);
 }
 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});
+log.finer("Window {0} is not resizable", this);
 flags |= XUtilConstants.PMinSize | XUtilConstants.PMaxSize | XUtilConstants.PSize;
 } else {
-log.log(Level.FINER, "Window {0} is resizable", new Object[] {this});
+log.finer("Window {0} is resizable", this);
 }
 setSizeHints(flags, x, y, width, height);
 }
 void validateSurface() {

changeset 3938	ef327bd847c0
parent 2810	fa49c6a06baf
child 4259	b41995ac0c17
child 4214	0fa32d38146b