Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
jdk/src/solaris/classes/sun/awt/X11/XNETProtocol.java
changeset 4214 0fa32d38146b
parent 4191 ca8d3ef845c8
parent 3938 ef327bd847c0
child 4366 4446f3b8a9b4
equal deleted inserted replaced
4213:d4816adcd858 4214:0fa32d38146b 
    25 
    25 
    26 
    26 
    27 package sun.awt.X11;
 
    27 package sun.awt.X11;
 
    28 
    28 
    29 import java.awt.Frame;
 
    29 import java.awt.Frame;
 
    30 import java.util.logging.Level;
 
    30 import sun.util.logging.PlatformLogger;
 
    31 import java.util.logging.Logger;
 
       
    32 
    31 
    33 final class XNETProtocol extends XProtocol implements XStateProtocol, XLayerProtocol
 
    32 final class XNETProtocol extends XProtocol implements XStateProtocol, XLayerProtocol
 
    34 {
 
    33 {
 
    35     private final static Logger log = Logger.getLogger("sun.awt.X11.XNETProtocol");
 
    34     private final static PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XNETProtocol");
 
    36     private final static Logger iconLog = Logger.getLogger("sun.awt.X11.icon.XNETProtocol");
 
    35     private final static PlatformLogger iconLog = PlatformLogger.getLogger("sun.awt.X11.icon.XNETProtocol");
 
    37     private static Logger stateLog = Logger.getLogger("sun.awt.X11.states.XNETProtocol");
 
    36     private static PlatformLogger stateLog = PlatformLogger.getLogger("sun.awt.X11.states.XNETProtocol");
 
    38 
    37 
    39     /**
 
    38     /**
 
    40      * XStateProtocol
 
    39      * XStateProtocol
 
    41      */
 
    40      */
 
    42     public boolean supportsState(int state) {
 
    41     public boolean supportsState(int state) {
 
    43         return doStateProtocol() ; // TODO - check for Frame constants
 
    42         return doStateProtocol() ; // TODO - check for Frame constants
 
    44     }
 
    43     }
 
    45 
    44 
    46     public void setState(XWindowPeer window, int state) {
 
    45     public void setState(XWindowPeer window, int state) {
 
    47         if (log.isLoggable(Level.FINE)) log.fine("Setting state of " + window + " to " + state);
 
    46         if (log.isLoggable(PlatformLogger.FINE)) log.fine("Setting state of " + window + " to " + state);
 
    48         if (window.isShowing()) {
 
    47         if (window.isShowing()) {
 
    49             requestState(window, state);
 
    48             requestState(window, state);
 
    50         } else {
 
    49         } else {
 
    51             setInitialState(window, state);
 
    50             setInitialState(window, state);
 
    52         }
 
    51         }
 
    53     }
 
    52     }
 
    54 
    53 
    55     private void setInitialState(XWindowPeer window, int state) {
 
    54     private void setInitialState(XWindowPeer window, int state) {
 
    56         XAtomList old_state = window.getNETWMState();
 
    55         XAtomList old_state = window.getNETWMState();
 
    57         if (log.isLoggable(Level.FINE)) {
 
    56         log.fine("Current state of the window {0} is {1}", window, old_state);
 
    58             log.log(Level.FINE, "Current state of the window {0} is {1}",
 
       
    59                     new Object[] {String.valueOf(window),
 
       
    60                                   String.valueOf(old_state)});
 
       
    61         }
 
       
    62         if ((state & Frame.MAXIMIZED_VERT) != 0) {
 
    57         if ((state & Frame.MAXIMIZED_VERT) != 0) {
 
    63             old_state.add(XA_NET_WM_STATE_MAXIMIZED_VERT);
 
    58             old_state.add(XA_NET_WM_STATE_MAXIMIZED_VERT);
 
    64         } else {
 
    59         } else {
 
    65             old_state.remove(XA_NET_WM_STATE_MAXIMIZED_VERT);
 
    60             old_state.remove(XA_NET_WM_STATE_MAXIMIZED_VERT);
 
    66         }
 
    61         }
 
    67         if ((state & Frame.MAXIMIZED_HORIZ) != 0) {
 
    62         if ((state & Frame.MAXIMIZED_HORIZ) != 0) {
 
    68             old_state.add(XA_NET_WM_STATE_MAXIMIZED_HORZ);
 
    63             old_state.add(XA_NET_WM_STATE_MAXIMIZED_HORZ);
 
    69         } else {
 
    64         } else {
 
    70             old_state.remove(XA_NET_WM_STATE_MAXIMIZED_HORZ);
 
    65             old_state.remove(XA_NET_WM_STATE_MAXIMIZED_HORZ);
 
    71         }
 
    66         }
 
    72         if (log.isLoggable(Level.FINE)) {
 
    67         log.fine("Setting initial state of the window {0} to {1}", window, old_state);
 
    73             log.log(Level.FINE, "Setting initial state of the window {0} to {1}",
 
       
    74                     new Object[] {String.valueOf(window), String.valueOf(old_state)});
 
       
    75         }
 
       
    76         window.setNETWMState(old_state);
 
    68         window.setNETWMState(old_state);
 
    77     }
 
    69     }
 
    78 
    70 
    79     private void requestState(XWindowPeer window, int state) {
 
    71     private void requestState(XWindowPeer window, int state) {
 
    80         /*
 
    72         /*
 
   103                   req.set_data(2, XA_NET_WM_STATE_MAXIMIZED_VERT.getAtom());
 
    95                   req.set_data(2, XA_NET_WM_STATE_MAXIMIZED_VERT.getAtom());
 
   104                   break;
 
    96                   break;
 
   105               default:
 
    97               default:
 
   106                   return;
 
    98                   return;
 
   107             }
 
    99             }
 
   108             if (log.isLoggable(Level.FINE)) log.fine("Requesting state on " + window + " for " + state);
 
   100             if (log.isLoggable(PlatformLogger.FINE)) log.fine("Requesting state on " + window + " for " + state);
 
   109             req.set_type((int)XConstants.ClientMessage);
 
   101             req.set_type((int)XConstants.ClientMessage);
 
   110             req.set_window(window.getWindow());
 
   102             req.set_window(window.getWindow());
 
   111             req.set_message_type(XA_NET_WM_STATE.getAtom());
 
   103             req.set_message_type(XA_NET_WM_STATE.getAtom());
 
   112             req.set_format(32);
 
   104             req.set_format(32);
 
   113             req.set_data(0, _NET_WM_STATE_TOGGLE);
 
   105             req.set_data(0, _NET_WM_STATE_TOGGLE);
 
   185             req.set_format(32);
 
   177             req.set_format(32);
 
   186             req.set_data(0, isAdd ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE);
 
   178             req.set_data(0, isAdd ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE);
 
   187             req.set_data(1, state.getAtom());
 
   179             req.set_data(1, state.getAtom());
 
   188             // Fix for 6735584: req.data[2] must be set to 0 when only one property is changed
 
   180             // Fix for 6735584: req.data[2] must be set to 0 when only one property is changed
 
   189             req.set_data(2, 0);
 
   181             req.set_data(2, 0);
 
   190             if (log.isLoggable(Level.FINE)) {
 
   182             log.fine("Setting _NET_STATE atom {0} on {1} for {2}", state, window, Boolean.valueOf(isAdd));
 
   191                 log.log(Level.FINE, "Setting _NET_STATE atom {0} on {1} for {2}",
 
       
   192                                     new Object[] {String.valueOf(state), String.valueOf(window),
 
       
   193                                                   Boolean.valueOf(isAdd)});
 
       
   194             }
 
       
   195             XToolkit.awtLock();
 
   183             XToolkit.awtLock();
 
   196             try {
 
   184             try {
 
   197                 XlibWrapper.XSendEvent(XToolkit.getDisplay(),
 
   185                 XlibWrapper.XSendEvent(XToolkit.getDisplay(),
 
   198                         XlibWrapper.RootWindow(XToolkit.getDisplay(), window.getScreenNumber()),
 
   186                         XlibWrapper.RootWindow(XToolkit.getDisplay(), window.getScreenNumber()),
 
   199                         false,
 
   187                         false,
 
   214      * @param window Window which NET_WM_STATE property is being modified
 
   202      * @param window Window which NET_WM_STATE property is being modified
 
   215      * @param state State atom to be set/reset
 
   203      * @param state State atom to be set/reset
 
   216      * @param reset Indicates operation, 'set' if false, 'reset' if true
 
   204      * @param reset Indicates operation, 'set' if false, 'reset' if true
 
   217      */
 
   205      */
 
   218     private void setStateHelper(XWindowPeer window, XAtom state, boolean set) {
 
   206     private void setStateHelper(XWindowPeer window, XAtom state, boolean set) {
 
   219         log.log(Level.FINER, "Window visibility is: withdrawn={0}, visible={1}, mapped={2} showing={3}",
 
   207         log.finer("Window visibility is: withdrawn={0}, visible={1}, mapped={2} showing={3}",
 
   220                 new Object[] {Boolean.valueOf(window.isWithdrawn()), Boolean.valueOf(window.isVisible()),
 
   208                   Boolean.valueOf(window.isWithdrawn()), Boolean.valueOf(window.isVisible()),
 
   221                               Boolean.valueOf(window.isMapped()), Boolean.valueOf(window.isShowing())});
 
   209                   Boolean.valueOf(window.isMapped()), Boolean.valueOf(window.isShowing()));
 
   222         if (window.isShowing()) {
 
   210         if (window.isShowing()) {
 
   223             requestState(window, state, set);
 
   211             requestState(window, state, set);
 
   224         } else {
 
   212         } else {
 
   225             XAtomList net_wm_state = window.getNETWMState();
 
   213             XAtomList net_wm_state = window.getNETWMState();
 
   226             if (log.isLoggable(Level.FINE)) {
 
   214             log.finer("Current state on {0} is {1}", window, net_wm_state);
 
   227                 log.log(Level.FINE, "Current state on {0} is {1}",
 
       
   228                         new Object[] {String.valueOf(window), net_wm_state});
 
       
   229             }
 
       
   230             if (!set) {
 
   215             if (!set) {
 
   231                 net_wm_state.remove(state);
 
   216                 net_wm_state.remove(state);
 
   232             } else {
 
   217             } else {
 
   233                 net_wm_state.add(state);
 
   218                 net_wm_state.add(state);
 
   234             }
 
   219             }
 
   235             if (log.isLoggable(Level.FINE)) {
 
   220             log.fine("Setting states on {0} to {1}", window, net_wm_state);
 
   236                 log.log(Level.FINE, "Setting states on {0} to {1}",
 
       
   237                         new Object[] {String.valueOf(window), net_wm_state});
 
       
   238             }
 
       
   239             window.setNETWMState(net_wm_state);
 
   221             window.setNETWMState(net_wm_state);
 
   240         }
 
   222         }
 
   241         XToolkit.XSync();
 
   223         XToolkit.XSync();
 
   242     }
 
   224     }
 
   243 
   225 
   287             // TODO: How about detecting WM-restart or exit?
 
   269             // TODO: How about detecting WM-restart or exit?
 
   288             return;
 
   270             return;
 
   289         }
 
   271         }
 
   290         NetWindow = checkAnchor(XA_NET_SUPPORTING_WM_CHECK, XAtom.XA_WINDOW);
 
   272         NetWindow = checkAnchor(XA_NET_SUPPORTING_WM_CHECK, XAtom.XA_WINDOW);
 
   291         supportChecked = true;
 
   273         supportChecked = true;
 
   292         if (log.isLoggable(Level.FINE)) log.fine("### " + this + " is active: " + (NetWindow != 0));
 
   274         if (log.isLoggable(PlatformLogger.FINE)) log.fine("### " + this + " is active: " + (NetWindow != 0));
 
   293     }
 
   275     }
 
   294 
   276 
   295     boolean active() {
 
   277     boolean active() {
 
   296         detect();
 
   278         detect();
 
   297         return NetWindow != 0;
 
   279         return NetWindow != 0;
 
   324         }
 
   306         }
 
   325         String net_wm_name_string = getWMName();
 
   307         String net_wm_name_string = getWMName();
 
   326         if (net_wm_name_string == null) {
 
   308         if (net_wm_name_string == null) {
 
   327             return false;
 
   309             return false;
 
   328         }
 
   310         }
 
   329         if (log.isLoggable(Level.FINE)) log.fine("### WM_NAME = " + net_wm_name_string);
 
   311         if (log.isLoggable(PlatformLogger.FINE)) log.fine("### WM_NAME = " + net_wm_name_string);
 
   330         return net_wm_name_string.startsWith(name);
 
   312         return net_wm_name_string.startsWith(name);
 
   331     }
 
   313     }
 
   332 
   314 
   333     String net_wm_name_cache;
 
   315     String net_wm_name_cache;
 
   334     public String getWMName() {
 
   316     public String getWMName() {
jdk-sandbox