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

equal deleted inserted replaced

-:487e1aa949c4
+:ef327bd847c0
 import java.awt.Frame;
 import java.awt.Rectangle;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.LinkedList;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import sun.util.logging.PlatformLogger;
 /**
 * Class incapsulating knowledge about window managers in general
 * Descendants should provide some information about specific window manager.
 */
 final class XWM
 {
-private final static Logger log = Logger.getLogger("sun.awt.X11.XWM");
+private final static PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XWM");
-private final static Logger insLog = Logger.getLogger("sun.awt.X11.insets.XWM");
+private final static PlatformLogger insLog = PlatformLogger.getLogger("sun.awt.X11.insets.XWM");
-private final static Logger stateLog = Logger.getLogger("sun.awt.X11.states.XWM");
+private final static PlatformLogger stateLog = PlatformLogger.getLogger("sun.awt.X11.states.XWM");
 static final XAtom XA_MWM_HINTS = new XAtom();
 private static Unsafe unsafe = XlibWrapper.unsafe;
 static final Insets defaultInsets = new Insets(25, 5, 5, 5);
 XWM(int WMID) {
 this.WMID = WMID;
 initializeProtocols();
-if (log.isLoggable(Level.FINE)) log.fine("Window manager: " + toString());
+if (log.isLoggable(PlatformLogger.FINE)) log.fine("Window manager: " + toString());
 }
 int getID() {
 return WMID;
 }
 /*
 * Use NO_WM since in all other aspects eXcursion is like not
 * having a window manager running. I.e. it does not reparent
 * top level shells.
 */
-if (insLog.isLoggable(Level.FINE)) {
+if (insLog.isLoggable(PlatformLogger.FINE)) {
 insLog.finer("eXcursion means NO_WM");
 }
 return true;
 }
 final String selection_name = "WM_S" + default_screen_number;
 long selection_owner =
 XlibWrapper.XGetSelectionOwner(XToolkit.getDisplay(),
 XAtom.get(selection_name).getAtom());
-if (insLog.isLoggable(Level.FINE)) {
+if (insLog.isLoggable(PlatformLogger.FINE)) {
 insLog.finer("selection owner of " + selection_name
 + " is " + selection_owner);
 }
 if (selection_owner != XConstants.None) {
 substruct.set_event_mask(0);
 XlibWrapper.XChangeWindowAttributes(XToolkit.getDisplay(),
 XToolkit.getDefaultRootWindow(),
 XConstants.CWEventMask,
 substruct.pData);
-if (insLog.isLoggable(Level.FINE)) {
+if (insLog.isLoggable(PlatformLogger.FINE)) {
 insLog.finer("It looks like there is no WM thus NO_WM");
 }
 }
 return !winmgr_running;
 } else {
 log.finer("ENLIGHTENMENT_COMMS has wrong format");
 return 0;
 }
 } catch (Exception e) {
-if (log.isLoggable(Level.FINER)) {
+if (log.isLoggable(PlatformLogger.FINER)) {
 e.printStackTrace();
 }
 return 0;
 }
 } finally {
 static final XAtom XA_DT_SM_WINDOW_INFO = new XAtom("_DT_SM_WINDOW_INFO", false);
 static final XAtom XA_DT_SM_STATE_INFO = new XAtom("_DT_SM_STATE_INFO", false);
 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});
+log.finer("{0} is not interned", XA_DT_SM_WINDOW_INFO);
 return false;
 }
 WindowPropertyGetter getter =
 new WindowPropertyGetter(XToolkit.getDefaultRootWindow(),
 return false;
 }
 /* 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});
+log.finer("{0} is not interned", XA_DT_SM_STATE_INFO);
 return false;
 }
 WindowPropertyGetter getter2 =
 new WindowPropertyGetter(wmwin, XA_DT_SM_STATE_INFO, 0, 1,
 false, XA_DT_SM_STATE_INFO);
 * Choose something innocuous: "AWT_ICEWM_TEST allWorkspaces 0".
 * IceWM expects "class\0option\0arg\0" with zero bytes as delimiters.
 */
 if (!XA_ICEWM_WINOPTHINT.isInterned()) {
-log.log(Level.FINER, "{0} is not interned", new Object[] {XA_ICEWM_WINOPTHINT});
+log.finer("{0} is not interned", XA_ICEWM_WINOPTHINT);
 return false;
 }
 XToolkit.awtLock();
 try {
 * Note well: Only call this if awt_wm_prepareIsIceWM succeeded, or a
 * false positive will be reported.
 */
 static boolean isIceWM() {
 if (!XA_ICEWM_WINOPTHINT.isInterned()) {
-log.log(Level.FINER, "{0} is not interned", new Object[] {XA_ICEWM_WINOPTHINT});
+log.finer("{0} is not interned", XA_ICEWM_WINOPTHINT);
 return false;
 }
 WindowPropertyGetter getter =
 new WindowPropertyGetter(XToolkit.getDefaultRootWindow(),
 wm = new XWM(awt_wmgr = getWMID()/*XWM.OTHER_WM*/);
 }
 return wm;
 }
 static int getWMID() {
-if (insLog.isLoggable(Level.FINEST)) {
+if (insLog.isLoggable(PlatformLogger.FINEST)) {
 insLog.finest("awt_wmgr = " + awt_wmgr);
 }
 /*
 * Ideally, we should support cases when a different WM is started
 * during a Java app lifetime.
 // Initialize _NET protocol - used to detect Window Manager.
 // Later, WM will initialize its own version of protocol
 XNETProtocol l_net_protocol = g_net_protocol = new XNETProtocol();
 l_net_protocol.detect();
-if (log.isLoggable(Level.FINE) && l_net_protocol.active()) {
+if (log.isLoggable(PlatformLogger.FINE) && l_net_protocol.active()) {
 log.fine("_NET_WM_NAME is " + l_net_protocol.getWMName());
 }
 XWINProtocol win = g_win_protocol = new XWINProtocol();
 win.detect();
 if ((hints.get_flags() & mask) == 0) {
 return;
 }
 hints.set_flags(hints.get_flags() & ~mask);
-if (insLog.isLoggable(Level.FINER)) insLog.finer("Setting hints, flags " + XlibWrapper.hintsToString(hints.get_flags()));
+if (insLog.isLoggable(PlatformLogger.FINER)) insLog.finer("Setting hints, flags " + XlibWrapper.hintsToString(hints.get_flags()));
 XlibWrapper.XSetWMNormalHints(XToolkit.getDisplay(),
 window.getWindow(),
 hints.pData);
 } finally {
 XToolkit.awtUnlock();
 return;
 }
 XAtomList decorDel = new XAtomList();
 decorations = normalizeMotifDecor(decorations);
-if (insLog.isLoggable(Level.FINER)) insLog.finer("Setting OL_DECOR to " + Integer.toBinaryString(decorations));
+if (insLog.isLoggable(PlatformLogger.FINER)) insLog.finer("Setting OL_DECOR to " + Integer.toBinaryString(decorations));
 if ((decorations & MWMConstants.MWM_DECOR_TITLE) == 0) {
 decorDel.add(XA_OL_DECOR_HEADER);
 }
 if ((decorations & (MWMConstants.MWM_DECOR_RESIZEH | MWMConstants.MWM_DECOR_MAXIMIZE)) == 0) {
 decorDel.add(XA_OL_DECOR_RESIZE);
 }
 if (decorDel.size() == 0) {
 insLog.finer("Deleting OL_DECOR");
 XA_OL_DECOR_DEL.DeleteProperty(window);
 } else {
-if (insLog.isLoggable(Level.FINER)) insLog.finer("Setting OL_DECOR to " + decorDel);
+if (insLog.isLoggable(PlatformLogger.FINER)) insLog.finer("Setting OL_DECOR to " + decorDel);
 XA_OL_DECOR_DEL.setAtomListProperty(window, decorDel);
 }
 }
 /*
 MWMConstants.MWM_HINTS_FUNCTIONS |
 MWMConstants.MWM_HINTS_DECORATIONS);
 hints.set_functions(functions);
 hints.set_decorations(decorations);
-if (stateLog.isLoggable(Level.FINER)) stateLog.finer("Setting MWM_HINTS to " + hints);
+if (stateLog.isLoggable(PlatformLogger.FINER)) stateLog.finer("Setting MWM_HINTS to " + hints);
 window.setMWMHints(hints);
 }
 /*
 * Under some window managers if shell is already mapped, we MUST
 /*
 * Make specified shell resizable.
 */
 static void setShellResizable(XDecoratedPeer window) {
-if (insLog.isLoggable(Level.FINE)) insLog.fine("Setting shell resizable " + window);
+if (insLog.isLoggable(PlatformLogger.FINE)) insLog.fine("Setting shell resizable " + window);
 XToolkit.awtLock();
 try {
 Rectangle shellBounds = window.getShellBounds();
 shellBounds.translate(-window.currentInsets.left, -window.currentInsets.top);
 window.updateSizeHints(window.getDimensions());
 * @param shellBounds bounds of the shell window
 */
 static void setShellNotResizable(XDecoratedPeer window, WindowDimensions newDimensions, Rectangle shellBounds,
 boolean justChangeSize)
 {
-if (insLog.isLoggable(Level.FINE)) insLog.fine("Setting non-resizable shell " + window + ", dimensions " + newDimensions +
+if (insLog.isLoggable(PlatformLogger.FINE)) insLog.fine("Setting non-resizable shell " + window + ", dimensions " + newDimensions +
 ", shellBounds " + shellBounds +", just change size: " + justChangeSize);
 XToolkit.awtLock();
 try {
 /* Fix min/max size hints at the specified values */
 if (!shellBounds.isEmpty()) {
 case OPENLOOK_WM:
 default:
 res = defaultInsets;
 }
 }
-if (insLog.isLoggable(Level.FINEST)) insLog.finest("WM guessed insets: " + res);
+if (insLog.isLoggable(PlatformLogger.FINEST)) insLog.finest("WM guessed insets: " + res);
 return res;
 }
 /*
 * Some buggy WMs ignore window gravity when processing
 * ConfigureRequest and position window as if the gravity is Static.
 return null;
 }
 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);
+insLog.fine("_NET_FRAME_EXTENTS: {0}", insets);
 if (insets != null) {
 return insets;
 }
 }
 *       parent is a lining exactly the size of the client
 *       grandpa is the WM frame
 *       [mwm, e!, kwin, fvwm2 ... ]
 */
 Insets correctWM = XWM.getInsetsFromExtents(window);
-insLog.log(Level.FINER, "Got insets from property: {0}", correctWM);
+insLog.finer("Got insets from property: {0}", correctWM);
 if (correctWM == null) {
 correctWM = new Insets(0,0,0,0);
 correctWM.top = -1;
 correctWM.bottom = correctWM.left;
 break;
 }
 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);
+insLog.finest("Getting correct insets for OTHER_WM/default, parent: {0}", parent);
 syncTopLevelPos(parent, lwinAttr);
 int status = XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(),
 window, lwinAttr.pData);
 status = XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(),
 parent, pattr.pData);
 */
 if (lwinAttr.get_x() == 0 && lwinAttr.get_y() == 0
 && 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}",
+insLog.finest("Double reparenting detected, pattr({2})={0}, lwinAttr({3})={1}",
-new Object[] {lwinAttr, pattr, parent, window});
+lwinAttr, pattr, parent, 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());
 final long grand_parent = XlibUtil.getParentWindow(parent);
 * parent's border-width into account too, but the
 * rest of the code is happily unaware about border
 * 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}",
+insLog.finest("Attrs before calculation: pattr({2})={0}, lwinAttr({3})={1}",
-new Object[] {lwinAttr, pattr, parent, window});
+lwinAttr, pattr, parent, 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()),
 pattr.get_width() -  (lwinAttr.get_x() + lwinAttr.get_width() + 2*lwinAttr.get_border_width()));
 break;

changeset 3938	ef327bd847c0
parent 2802	d05a9dcc8296
child 4214	0fa32d38146b