1 /*

     2  * Copyright (c) 2001, 2006, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #ifdef HEADLESS

    27     #error This file should not be included in headless library

    28 #endif

    29 

    30 /*

    31  * Some SCIENCE stuff happens, and it is CONFUSING

    32  */

    33 

    34 #include "awt_p.h"

    35 

    36 #include <X11/Xproto.h>

    37 #include <X11/Xlib.h>

    38 #include <X11/Xatom.h>

    39 #include <Xm/MwmUtil.h>

    40 

    41 /* JNI headers */

    42 #include "java_awt_Frame.h"     /* for frame state constants */

    43 

    44 #include "awt_wm.h"

    45 #include "awt_util.h"           /* for X11 error handling macros */

    46 

    47 /*

    48  * NB: 64 bit awareness.

    49  *

    50  * Since this code reads/writes window properties heavily, one thing

    51  * should be noted well.  Xlib uses C type 'long' for properties of

    52  * format 32.  Fortunately, typedef for Atom is 'long' as well, so

    53  * passing property data as or casting returned property data to

    54  * arrays of atoms is safe.

    55  */

    56 

    57 

    58 /*

    59  * Atoms used to communicate with window manager(s).

    60  * Naming convention:

    61  *   o  for atom  "FOO" the variable is  "XA_FOO"

    62  *   o  for atom "_BAR" the variable is "_XA_BAR"

    63  * Don't forget to add initialization to awt_wm_initAtoms below.

    64  */

    65 

    66 /*

    67  * Before WM rototill JDK used to check for running WM by just testing

    68  * if certain atom is interned or not.  We'd better not confuse older

    69  * JDK by interning these atoms.  Use awt_wm_atomInterned() to intern

    70  * them lazily.

    71  *

    72  * ENLIGHTENMENT_COMMS

    73  * _ICEWM_WINOPTHINT

    74  * _SAWMILL_TIMESTAMP

    75  * _DT_SM_WINDOW_INFO

    76  * _MOTIF_WM_INFO

    77  * _SUN_WM_PROTOCOLS

    78  */

    79 

    80 /* Good old ICCCM */

    81 static Atom XA_WM_STATE;

    82 

    83 /* New "netwm" spec from www.freedesktop.org */

    84 static Atom XA_UTF8_STRING;     /* like STRING but encoding is UTF-8 */

    85 static Atom _XA_NET_SUPPORTING_WM_CHECK;

    86 static Atom _XA_NET_SUPPORTED;  /* list of protocols (property of root) */

    87 static Atom _XA_NET_WM_NAME;    /* window property */

    88 static Atom _XA_NET_WM_STATE;   /* both window property and request */

    89 

    90 /*

    91  * _NET_WM_STATE is a list of atoms.

    92  * NB: Standard spelling is "HORZ" (yes, without an 'I'), but KDE2

    93  * uses misspelled "HORIZ" (see KDE bug #20229).  This was fixed in

    94  * KDE 2.2.  Under earlier versions of KDE2 horizontal and full

    95  * maximization doesn't work .

    96  */

    97 static Atom _XA_NET_WM_STATE_MAXIMIZED_HORZ;

    98 static Atom _XA_NET_WM_STATE_MAXIMIZED_VERT;

    99 static Atom _XA_NET_WM_STATE_SHADED;

   100 static Atom _XA_NET_WM_STATE_ABOVE;

   101 static Atom _XA_NET_WM_STATE_BELOW;

   102 static Atom _XA_NET_WM_STATE_HIDDEN;

   103 

   104 /* Currently we only care about max_v and max_h in _NET_WM_STATE */

   105 #define AWT_NET_N_KNOWN_STATES 2

   106 

   107 /* Gnome WM spec (superseded by "netwm" above, but still in use) */

   108 static Atom _XA_WIN_SUPPORTING_WM_CHECK;

   109 static Atom _XA_WIN_PROTOCOLS;

   110 static Atom _XA_WIN_STATE;

   111 static Atom _XA_WIN_LAYER;

   112 

   113 /* Enlightenment */

   114 static Atom _XA_E_FRAME_SIZE;

   115 

   116 /* KWin (KDE2) */

   117 static Atom _XA_KDE_NET_WM_FRAME_STRUT;

   118 

   119 /* KWM (KDE 1.x) OBSOLETE??? */

   120 static Atom XA_KWM_WIN_ICONIFIED;

   121 static Atom XA_KWM_WIN_MAXIMIZED;

   122 

   123 /* OpenLook */

   124 static Atom _XA_OL_DECOR_DEL;

   125 static Atom _XA_OL_DECOR_HEADER;

   126 static Atom _XA_OL_DECOR_RESIZE;

   127 static Atom _XA_OL_DECOR_PIN;

   128 static Atom _XA_OL_DECOR_CLOSE;

   129 

   130 /* For _NET_WM_STATE ClientMessage requests */

   131 #define _NET_WM_STATE_REMOVE    0 /* remove/unset property */

   132 #define _NET_WM_STATE_ADD       1 /* add/set property      */

   133 #define _NET_WM_STATE_TOGGLE    2 /* toggle property       */

   134 

   135 /* _WIN_STATE bits */

   136 #define WIN_STATE_STICKY          (1<<0) /* everyone knows sticky            */

   137 #define WIN_STATE_MINIMIZED       (1<<1) /* Reserved - definition is unclear */

   138 #define WIN_STATE_MAXIMIZED_VERT  (1<<2) /* window in maximized V state      */

   139 #define WIN_STATE_MAXIMIZED_HORIZ (1<<3) /* window in maximized H state      */

   140 #define WIN_STATE_HIDDEN          (1<<4) /* not on taskbar but window visible*/

   141 #define WIN_STATE_SHADED          (1<<5) /* shaded (MacOS / Afterstep style) */

   142 #define WIN_LAYER_ONTOP           6

   143 #define WIN_LAYER_NORMAL          4

   144 

   145 #define  URGENCY_HINT             (1<<8)

   146 #define  LAYER_ALWAYS_ON_TOP      1

   147 #define  LAYER_NORMAL             0

   148 

   149 

   150 /*

   151  * Intern a bunch of atoms we are going use.

   152  */

   153 static void

   154 awt_wm_initAtoms(void)

   155 {

   156     /* Minimize X traffic by creating atoms en mass...  This requires

   157        slightly more code but reduces number of server requests. */

   158     struct atominit {

   159         Atom *atomptr;

   160         const char *name;

   161     };

   162 

   163     /* Just add new atoms to this list */

   164     static struct atominit atom_list[] = {

   165         { &XA_WM_STATE,                      "WM_STATE"                      },

   166 

   167         { &XA_UTF8_STRING,                   "UTF8_STRING"                   },

   168 

   169         { &_XA_NET_SUPPORTING_WM_CHECK,      "_NET_SUPPORTING_WM_CHECK"      },

   170         { &_XA_NET_SUPPORTED,                "_NET_SUPPORTED"                },

   171         { &_XA_NET_WM_STATE,                 "_NET_WM_STATE"                 },

   172         { &_XA_NET_WM_STATE_MAXIMIZED_VERT,  "_NET_WM_STATE_MAXIMIZED_VERT"  },

   173         { &_XA_NET_WM_STATE_MAXIMIZED_HORZ,  "_NET_WM_STATE_MAXIMIZED_HORZ"  },

   174         { &_XA_NET_WM_STATE_SHADED,          "_NET_WM_STATE_SHADED"          },

   175         { &_XA_NET_WM_STATE_ABOVE,           "_NET_WM_STATE_ABOVE"           },

   176         { &_XA_NET_WM_STATE_BELOW,           "_NET_WM_STATE_BELOW"           },

   177         { &_XA_NET_WM_STATE_HIDDEN,          "_NET_WM_STATE_HIDDEN"          },

   178         { &_XA_NET_WM_NAME,                  "_NET_WM_NAME"                  },

   179 

   180         { &_XA_WIN_SUPPORTING_WM_CHECK,      "_WIN_SUPPORTING_WM_CHECK"      },

   181         { &_XA_WIN_PROTOCOLS,                "_WIN_PROTOCOLS"                },

   182         { &_XA_WIN_STATE,                    "_WIN_STATE"                    },

   183         { &_XA_WIN_LAYER,                    "_WIN_LAYER"                    },

   184 

   185         { &_XA_KDE_NET_WM_FRAME_STRUT,       "_KDE_NET_WM_FRAME_STRUT"       },

   186 

   187         { &_XA_E_FRAME_SIZE,                 "_E_FRAME_SIZE"                 },

   188 

   189         { &XA_KWM_WIN_ICONIFIED,             "KWM_WIN_ICONIFIED"             },

   190         { &XA_KWM_WIN_MAXIMIZED,             "KWM_WIN_MAXIMIZED"             },

   191 

   192         { &_XA_OL_DECOR_DEL,                 "_OL_DECOR_DEL"                 },

   193         { &_XA_OL_DECOR_HEADER,              "_OL_DECOR_HEADER"              },

   194         { &_XA_OL_DECOR_RESIZE,              "_OL_DECOR_RESIZE"              },

   195         { &_XA_OL_DECOR_PIN,                 "_OL_DECOR_PIN"                 },

   196         { &_XA_OL_DECOR_CLOSE,               "_OL_DECOR_CLOSE"               }

   197     };

   198 #define ATOM_LIST_LENGTH (sizeof(atom_list)/sizeof(atom_list[0]))

   199 

   200     const char *names[ATOM_LIST_LENGTH];

   201     Atom atoms[ATOM_LIST_LENGTH];

   202     Status status;

   203     size_t i;

   204 

   205     /* Fill the array of atom names */

   206     for (i = 0; i < ATOM_LIST_LENGTH; ++i) {

   207         names[i] = atom_list[i].name;

   208     }

   209 

   210     DTRACE_PRINT("WM: initializing atoms ...  ");

   211     status = XInternAtoms(awt_display, (char**)names, ATOM_LIST_LENGTH,

   212                           False, atoms);

   213     if (status == 0) {

   214         DTRACE_PRINTLN("failed");

   215         return;

   216     }

   217 

   218     /* Store returned atoms into corresponding global variables */

   219     DTRACE_PRINTLN("ok");

   220     for (i = 0; i < ATOM_LIST_LENGTH; ++i) {

   221         *atom_list[i].atomptr = atoms[i];

   222     }

   223 #undef ATOM_LIST_LENGTH

   224 }

   225 

   226 

   227 /*

   228  * When checking for various WMs don't intern certain atoms we use to

   229  * distinguish those WMs.  Rather check if the atom is interned first.

   230  * If it's not, further tests are not necessary anyway.

   231  * This also saves older JDK a great deal of confusion (4487993).

   232  */

   233 static Boolean

   234 awt_wm_atomInterned(Atom *pa, const char *name)

   235 {

   236     DASSERT(pa != NULL);

   237     if (*pa == None) {

   238         DASSERT(name != NULL);

   239         *pa = XInternAtom(awt_display, name, True);

   240         if (*pa == None) {

   241             DTRACE_PRINTLN1("\"%s\" is not interned", name);

   242             return False;

   243         } else {

   244             return True;

   245         }

   246     } else {

   247         return True;

   248     }

   249 }

   250 

   251 

   252 

   253 /*****************************************************************************\

   254  *

   255  * DTRACE utils for various states ...

   256  *

   257 \*****************************************************************************/

   258 

   259 

   260 static void

   261 awt_wm_dtraceWMState(uint32_t wm_state)

   262 {

   263 #ifdef DEBUG

   264     DTRACE_PRINT("WM_STATE = ");

   265     switch (wm_state) {

   266       case WithdrawnState:

   267           DTRACE_PRINTLN("Withdrawn");

   268           break;

   269       case NormalState:

   270           DTRACE_PRINTLN("Normal");

   271           break;

   272       case IconicState:

   273           DTRACE_PRINTLN("Iconic");

   274           break;

   275       default:

   276           DTRACE_PRINTLN1("unknown state %d", wm_state);

   277           break;

   278     }

   279 #endif /* DEBUG */

   280 }

   281 

   282 static void

   283 awt_wm_dtraceStateNet(Atom *net_wm_state, unsigned long nitems)

   284 {

   285 #ifdef DEBUG

   286     unsigned long i;

   287 

   288     DTRACE_PRINT("_NET_WM_STATE = {");

   289     for (i = 0; i < nitems; ++i) {

   290         char *name, *print_name;

   291         name = XGetAtomName(awt_display, net_wm_state[i]);

   292         if (name == NULL) {

   293             print_name = "???";

   294         } else if (strncmp(name, "_NET_WM_STATE", 13) == 0) {

   295             print_name = name + 13; /* skip common prefix to reduce noice */

   296         } else {

   297             print_name = name;

   298         }

   299         DTRACE_PRINT1(" %s", print_name);

   300         if (name) {

   301             XFree(name);

   302         }

   303     }

   304     DTRACE_PRINTLN(" }");

   305 #endif

   306 }

   307 

   308 

   309 static void

   310 awt_wm_dtraceStateWin(uint32_t win_state)

   311 {

   312 #ifdef DEBUG

   313     DTRACE_PRINT("_WIN_STATE = {");

   314     if (win_state & WIN_STATE_STICKY) {

   315         DTRACE_PRINT(" STICKY");

   316     }

   317     if (win_state & WIN_STATE_MINIMIZED) {

   318         DTRACE_PRINT(" MINIMIZED");

   319     }

   320     if (win_state & WIN_STATE_MAXIMIZED_VERT) {

   321         DTRACE_PRINT(" MAXIMIZED_VERT");

   322     }

   323     if (win_state & WIN_STATE_MAXIMIZED_HORIZ) {

   324         DTRACE_PRINT(" MAXIMIZED_HORIZ");

   325     }

   326     if (win_state & WIN_STATE_HIDDEN) {

   327         DTRACE_PRINT(" HIDDEN");

   328     }

   329     if (win_state & WIN_STATE_SHADED) {

   330         DTRACE_PRINT(" SHADED");

   331     }

   332     DTRACE_PRINTLN(" }");

   333 #endif

   334 }

   335 

   336 

   337 static void

   338 awt_wm_dtraceStateJava(jint java_state)

   339 {

   340 #ifdef DEBUG

   341     DTRACE_PRINT("java state = ");

   342     if (java_state == java_awt_Frame_NORMAL) {

   343         DTRACE_PRINTLN("NORMAL");

   344     }

   345     else {

   346         DTRACE_PRINT("{");

   347         if (java_state & java_awt_Frame_ICONIFIED) {

   348             DTRACE_PRINT(" ICONIFIED");

   349         }

   350         if ((java_state & java_awt_Frame_MAXIMIZED_BOTH)

   351                        == java_awt_Frame_MAXIMIZED_BOTH)

   352         {

   353             DTRACE_PRINT(" MAXIMIZED_BOTH");

   354         }

   355         else if (java_state & java_awt_Frame_MAXIMIZED_HORIZ) {

   356             DTRACE_PRINT(" MAXIMIZED_HORIZ");

   357         }

   358         else if (java_state & java_awt_Frame_MAXIMIZED_VERT) {

   359             DTRACE_PRINT(" MAXIMIZED_VERT");

   360         }

   361         DTRACE_PRINTLN(" }");

   362     }

   363 #endif /* DEBUG */

   364 }

   365 

   366 

   367 

   368 /*****************************************************************************\

   369  *

   370  * Utility functions ...

   371  *

   372 \*****************************************************************************/

   373 

   374 /*

   375  * Instead of validating window id, we simply call XGetWindowProperty,

   376  * but temporary install this function as the error handler to ignore

   377  * BadWindow error.

   378  */

   379 int /* but ingored */

   380 xerror_ignore_bad_window(Display *dpy, XErrorEvent *err)

   381 {

   382     XERROR_SAVE(err);

   383     if (err->error_code == BadWindow) {

   384         DTRACE_PRINTLN("IGNORING BadWindow");

   385         return 0; /* ok to fail */

   386     }

   387     else {

   388         return (*xerror_saved_handler)(dpy, err);

   389     }

   390 }

   391 

   392 

   393 /*

   394  * Convenience wrapper for XGetWindowProperty for XA_ATOM properties.

   395  * E.g. WM_PROTOCOLS, _NET_WM_STATE, _OL_DECOR_DEL.

   396  * It's up to caller to XFree returned value.

   397  * Number of items returned is stored to nitems_ptr (if non-null).

   398  */

   399 static Atom *

   400 awt_getAtomListProperty(Window w, Atom property, unsigned long *nitems_ptr)

   401 {

   402     /* Request status */

   403     int status;

   404 

   405     /* Returns of XGetWindowProperty */

   406     Atom actual_type;

   407     int actual_format;

   408     unsigned long nitems_stub;

   409     unsigned long bytes_after;

   410     Atom *list;

   411 

   412     if (nitems_ptr == NULL) {

   413         /* Caller is not interested in the number of items,

   414            provide a stub for XGetWindowProperty */

   415         nitems_ptr = &nitems_stub;

   416     }

   417 

   418     status = XGetWindowProperty(awt_display, w,

   419                  property, 0, 0xFFFF, False, XA_ATOM,

   420                  &actual_type, &actual_format, nitems_ptr, &bytes_after,

   421                  (unsigned char **)&list);

   422 

   423     if (status != Success || list == NULL) {

   424         *nitems_ptr = 0;

   425         return NULL;

   426     }

   427 

   428     if (actual_type != XA_ATOM || actual_format != 32) {

   429         XFree(list);

   430         *nitems_ptr = 0;

   431         return NULL;

   432     }

   433 

   434     if (*nitems_ptr == 0) {

   435         XFree(list);

   436         return NULL;

   437     }

   438 

   439     return list;

   440 }

   441 

   442 

   443 /*

   444  * Auxiliary function that returns the value of 'property' of type

   445  * 'property_type' on window 'w'.  Format of the property must be 8.

   446  * Terminating zero added by XGetWindowProperty is preserved.

   447  * It's up to caller to XFree the result.

   448  */

   449 static unsigned char *

   450 awt_getProperty8(Window w, Atom property, Atom property_type)

   451 {

   452     /* Request status */

   453     int status;

   454 

   455     /* Returns of XGetWindowProperty */

   456     Atom actual_type;

   457     int actual_format;

   458     unsigned long nitems;

   459     unsigned long bytes_after;

   460     unsigned char *string;

   461 

   462     /* BadWindow is ok and will be blocked by our special handler */

   463     WITH_XERROR_HANDLER(xerror_ignore_bad_window);

   464     {

   465         status = XGetWindowProperty(awt_display, w,

   466                      property, 0, 0xFFFF, False, property_type,

   467                      &actual_type, &actual_format, &nitems, &bytes_after,

   468                      &string);

   469     }

   470     RESTORE_XERROR_HANDLER;

   471 

   472     if (status != Success || string == NULL) {

   473         return NULL;

   474     }

   475 

   476     if (actual_type != property_type || actual_format != 8) {

   477         XFree(string);

   478         return NULL;

   479     }

   480 

   481     /* XGetWindowProperty kindly supplies terminating zero */

   482     return string;

   483 }

   484 

   485 

   486 /*

   487  * Auxiliary function that returns the value of 'property' of type

   488  * 'property_type' on window 'w'.  Format of the property must be 32.

   489  */

   490 static int32_t

   491 awt_getProperty32(Window w, Atom property, Atom property_type)

   492 {

   493     /* Property value*/

   494     int32_t value;

   495 

   496     /* Request status */

   497     int status;

   498 

   499     /* Returns of XGetWindowProperty */

   500     Atom actual_type;

   501     int actual_format;

   502     unsigned long nitems;

   503     unsigned long bytes_after;

   504     long *data;                 /* NB: 64 bit: Format 32 props are 'long' */

   505 

   506     /* BadWindow is ok and will be blocked by our special handler */

   507     WITH_XERROR_HANDLER(xerror_ignore_bad_window);

   508     {

   509         status = XGetWindowProperty(awt_display, w,

   510                      property, 0, 1, False, property_type,

   511                      &actual_type, &actual_format, &nitems, &bytes_after,

   512                      (unsigned char **)&data);

   513     }

   514     RESTORE_XERROR_HANDLER;

   515 

   516     if (status != Success || data == NULL) {

   517         return 0;

   518     }

   519 

   520     if (actual_type != property_type || actual_format != 32) {

   521         XFree(data);            /* NULL data already catched above */

   522         return 0;

   523     }

   524 

   525     value = (int32_t)*data;

   526     XFree(data);

   527 

   528     return value;

   529 }

   530 

   531 

   532 

   533 /*****************************************************************************\

   534  *

   535  * Detecting WM ...

   536  *

   537 \*****************************************************************************/

   538 

   539 

   540 

   541 /*

   542  * Check for anchor_prop(anchor_type) on root, take the value as the

   543  * window id and check if that window exists and has anchor_prop(anchor_type)

   544  * with the same value (i.e. pointing back to self).

   545  *

   546  * Returns the anchor window, as some WM may put interesting stuff in

   547  * its properties (e.g. sawfish).

   548  */

   549 static Window

   550 awt_wm_checkAnchor(Atom anchor_prop, Atom anchor_type)

   551 {

   552     Window root_xref;

   553     Window self_xref;

   554 

   555     root_xref = (Window)awt_getProperty32(DefaultRootWindow(awt_display),

   556                                           anchor_prop, anchor_type);

   557     if (root_xref == None) {

   558         DTRACE_PRINTLN("no");

   559         return None;

   560     }

   561 

   562     DTRACE_PRINT1("0x%x ...  ", (unsigned int)root_xref);

   563     self_xref = (Window)awt_getProperty32(root_xref,

   564                                           anchor_prop, anchor_type);

   565     if (self_xref != root_xref) {

   566         DTRACE_PRINTLN("stale");

   567         return None;

   568     }

   569 

   570     DTRACE_PRINTLN("ok");

   571     return self_xref;

   572 }

   573 

   574 

   575 /*

   576  * New WM spec: KDE 2.0.1, sawfish 0.3x, ...

   577  * <http://www.freedesktop.org/standards/wm-spec.html>

   578  */

   579 static Window

   580 awt_wm_isNetSupporting(void)

   581 {

   582     static Boolean checked = False;

   583     static Window isNetSupporting = None;

   584 

   585     if (checked) {

   586         return isNetSupporting;

   587     }

   588 

   589     DTRACE_PRINT("WM: checking for _NET_SUPPORTING ...  ");

   590     isNetSupporting = awt_wm_checkAnchor(_XA_NET_SUPPORTING_WM_CHECK,

   591                                          XA_WINDOW);

   592     checked = True;

   593     return isNetSupporting;

   594 }

   595 

   596 

   597 /*

   598  * Old Gnome WM spec: WindowMaker, Enlightenment, IceWM ...

   599  * <http://developer.gnome.org/doc/standards/wm/book1.html>

   600  */

   601 static Window

   602 awt_wm_isWinSupporting(void)

   603 {

   604     static Boolean checked = False;

   605     static Window isWinSupporting = None;

   606 

   607     if (checked) {

   608         return isWinSupporting;

   609     }

   610 

   611     DTRACE_PRINT("WM: checking for _WIN_SUPPORTING ...  ");

   612     isWinSupporting = awt_wm_checkAnchor(_XA_WIN_SUPPORTING_WM_CHECK,

   613                                          XA_CARDINAL);

   614     checked = True;

   615     return isWinSupporting;

   616 }

   617 

   618 

   619 /*

   620  * Check that that the list of protocols specified by WM in property

   621  * named LIST_NAME on the root window contains protocol PROTO.

   622  */

   623 static Boolean

   624 awt_wm_checkProtocol(Atom list_name, Atom proto)

   625 {

   626     Atom *protocols;

   627     unsigned long nproto;

   628     Boolean found;

   629     unsigned long i;

   630 

   631     protocols = awt_getAtomListProperty(DefaultRootWindow(awt_display),

   632                                         list_name, &nproto);

   633     if (protocols == NULL) {

   634         return False;

   635     }

   636 

   637     found = False;

   638     for (i = 0; i < nproto; ++i) {

   639         if (protocols[i] == proto) {

   640             found = True;

   641             break;

   642         }

   643     }

   644 

   645     if (protocols != NULL) {

   646         XFree(protocols);

   647     }

   648     return found;

   649 }

   650 

   651 static Boolean

   652 awt_wm_doStateProtocolNet(void)

   653 {

   654     static Boolean checked = False;

   655     static Boolean supported = False;

   656 

   657     if (checked) {

   658         return supported;

   659     }

   660 

   661     if (awt_wm_isNetSupporting()) {

   662         DTRACE_PRINT("WM: checking for _NET_WM_STATE in _NET_SUPPORTED ...  ");

   663         supported = awt_wm_checkProtocol(_XA_NET_SUPPORTED, _XA_NET_WM_STATE);

   664         DTRACE_PRINTLN1("%s", supported ? "yes" : "no");

   665     }

   666 

   667     checked = True;

   668     return supported;

   669 }

   670 

   671 static Boolean

   672 awt_wm_doStateProtocolWin(void)

   673 {

   674     static Boolean checked = False;

   675     static Boolean supported = False;

   676 

   677     if (checked) {

   678         return supported;

   679     }

   680 

   681     if (awt_wm_isWinSupporting()) {

   682         DTRACE_PRINT("WM: checking for _WIN_STATE in _WIN_PROTOCOLS ...  ");

   683         supported = awt_wm_checkProtocol(_XA_WIN_PROTOCOLS, _XA_WIN_STATE);

   684         DTRACE_PRINTLN1("%s", supported ? "yes" : "no");

   685     }

   686     checked = True;

   687     return supported;

   688 }

   689 

   690 

   691 

   692 /*

   693  * Helper function for awt_wm_isEnlightenment.

   694  * Enlightenment uses STRING property for its comms window id.  Gaaa!

   695  * The property is ENLIGHTENMENT_COMMS, STRING/8 and the string format

   696  * is "WINID %8x".  Gee, I haven't been using scanf for *ages*... :-)

   697  */

   698 static Window

   699 awt_getECommsWindowIDProperty(Window w)

   700 {

   701     static Atom XA_ENLIGHTENMENT_COMMS = None;

   702 

   703     /* Property value*/

   704     Window value;

   705 

   706     /* Request status */

   707     int status;

   708 

   709     /* Returns of XGetWindowProperty */

   710     Atom actual_type;

   711     int actual_format;

   712     unsigned long nitems;

   713     unsigned long bytes_after;

   714     unsigned char *data;

   715 

   716     if (!awt_wm_atomInterned(&XA_ENLIGHTENMENT_COMMS, "ENLIGHTENMENT_COMMS")) {

   717         return False;

   718     }

   719 

   720     /* BadWindow is ok and will be blocked by our special handler */

   721     WITH_XERROR_HANDLER(xerror_ignore_bad_window);

   722     {

   723         status = XGetWindowProperty(awt_display, w,

   724                      XA_ENLIGHTENMENT_COMMS, 0, 14, False, XA_STRING,

   725                      &actual_type, &actual_format, &nitems, &bytes_after,

   726                      &data);

   727     }

   728     RESTORE_XERROR_HANDLER;

   729 

   730     if (status != Success || data == NULL) {

   731         DTRACE_PRINTLN("no ENLIGHTENMENT_COMMS");

   732         return None;

   733     }

   734 

   735     if (actual_type != XA_STRING || actual_format != 8

   736         || nitems != 14 || bytes_after != 0)

   737     {

   738         DTRACE_PRINTLN("malformed ENLIGHTENMENT_COMMS");

   739         XFree(data);            /* NULL data already catched above */

   740         return None;

   741     }

   742 

   743     value = None;

   744     sscanf((char *)data, "WINID %8lx", &value); /* NB: 64 bit: XID is long */

   745     XFree(data);

   746 

   747     return value;

   748 }

   749 

   750 

   751 /*

   752  * Is Enlightenment WM running?  Congruent to awt_wm_checkAnchor, but

   753  * uses STRING property peculiar to Enlightenment.

   754  */

   755 static Boolean

   756 awt_wm_isEnlightenment(void)

   757 {

   758     Window root_xref;

   759     Window self_xref;

   760 

   761     DTRACE_PRINT("WM: checking for Enlightenment ...  ");

   762     root_xref = awt_getECommsWindowIDProperty(DefaultRootWindow(awt_display));

   763     if (root_xref == None) {

   764         return False;

   765     }

   766 

   767     DTRACE_PRINT1("0x%x ...  ", root_xref);

   768     self_xref = awt_getECommsWindowIDProperty(root_xref);

   769     if (self_xref != root_xref) {

   770         return False;

   771     }

   772 

   773     DTRACE_PRINTLN("ok");

   774     return True;

   775 }

   776 

   777 

   778 /*

   779  * Is CDE running?

   780  *

   781  * XXX: This is hairy...  CDE is MWM as well.  It seems we simply test

   782  * for default setup and will be bitten if user changes things...

   783  *

   784  * Check for _DT_SM_WINDOW_INFO(_DT_SM_WINDOW_INFO) on root.  Take the

   785  * second element of the property and check for presence of

   786  * _DT_SM_STATE_INFO(_DT_SM_STATE_INFO) on that window.

   787  *

   788  * XXX: Any header that defines this structures???

   789  */

   790 static Boolean

   791 awt_wm_isCDE(void)

   792 {

   793     static Atom _XA_DT_SM_WINDOW_INFO = None;

   794     static Atom _XA_DT_SM_STATE_INFO = None;

   795 

   796     /* Property value*/

   797     Window wmwin;

   798 

   799     /* Request status */

   800     int status;

   801 

   802     /* Returns of XGetWindowProperty */

   803     Atom actual_type;

   804     int actual_format;

   805     unsigned long nitems;

   806     unsigned long bytes_after;

   807     long *data;                 /* NB: 64 bit: Format 32 props are 'long' */

   808 

   809     DTRACE_PRINT("WM: checking for CDE ...  ");

   810 

   811     if (!awt_wm_atomInterned(&_XA_DT_SM_WINDOW_INFO, "_DT_SM_WINDOW_INFO")) {

   812         return False;

   813     }

   814 

   815     status = XGetWindowProperty(awt_display, DefaultRootWindow(awt_display),

   816                  _XA_DT_SM_WINDOW_INFO, 0, 2, False, _XA_DT_SM_WINDOW_INFO,

   817                  &actual_type, &actual_format, &nitems, &bytes_after,

   818                  (unsigned char **)&data);

   819 

   820     if (status != Success || data == NULL) {

   821         DTRACE_PRINTLN("no _DT_SM_WINDOW_INFO on root");

   822         return False;

   823     }

   824 

   825     if (actual_type != _XA_DT_SM_WINDOW_INFO || actual_format != 32

   826         || nitems != 2 || bytes_after != 0)

   827     {

   828         DTRACE_PRINTLN("malformed _DT_SM_WINDOW_INFO on root");

   829         XFree(data);            /* NULL data already catched above */

   830         return False;

   831     }

   832 

   833     wmwin = (Window)data[1];

   834     XFree(data);

   835 

   836     /* Now check that this window has _DT_SM_STATE_INFO (ignore contents) */

   837 

   838     if (!awt_wm_atomInterned(&_XA_DT_SM_STATE_INFO, "_DT_SM_STATE_INFO")) {

   839         return False;

   840     }

   841 

   842     /* BadWindow is ok and will be blocked by our special handler */

   843     WITH_XERROR_HANDLER(xerror_ignore_bad_window);

   844     {

   845         status = XGetWindowProperty(awt_display, wmwin,

   846                      _XA_DT_SM_STATE_INFO, 0, 1, False, _XA_DT_SM_STATE_INFO,

   847                      &actual_type, &actual_format, &nitems, &bytes_after,

   848                      (unsigned char **)&data);

   849     }

   850     RESTORE_XERROR_HANDLER;

   851 

   852     if (status != Success || data == NULL) {

   853         DTRACE_PRINTLN("no _DT_SM_STATE_INFO");

   854         return False;

   855     }

   856 

   857     if (actual_type != _XA_DT_SM_STATE_INFO || actual_format != 32) {

   858         DTRACE_PRINTLN("malformed _DT_SM_STATE_INFO");

   859         XFree(data);            /* NULL data already catched above */

   860         return False;

   861     }

   862 

   863     DTRACE_PRINTLN("yes");

   864     XFree(data);

   865     return True;

   866 }

   867 

   868 /*

   869  * Is MWM running?  (Note that CDE will test positive as well).

   870  *

   871  * Check for _MOTIF_WM_INFO(_MOTIF_WM_INFO) on root.  Take the

   872  * second element of the property and check for presence of

   873  * _DT_SM_STATE_INFO(_DT_SM_STATE_INFO) on that window.

   874  */

   875 static Boolean

   876 awt_wm_isMotif(void)

   877 {

   878     /*

   879      * Grr.  Motif just had to be different, ain't it!?  Everyone use

   880      * "XA" for things of type Atom, but motif folks chose to define

   881      * _XA_MOTIF_* to be atom *names*.  How pathetic...

   882      */

   883 #undef _XA_MOTIF_WM_INFO

   884     static Atom _XA_MOTIF_WM_INFO = None;

   885     static Atom _XA_DT_WORKSPACE_CURRENT = None;

   886 

   887     /* Property value */

   888     Window wmwin;

   889     Atom *curws;

   890 

   891     /* Request status */

   892     int status;

   893 

   894     /* Returns of XGetWindowProperty */

   895     Atom actual_type;

   896     int actual_format;

   897     unsigned long nitems;

   898     unsigned long bytes_after;

   899     long *data;                 /* NB: 64 bit: Format 32 props are 'long' */

   900 

   901     DTRACE_PRINT("WM: checking for MWM ...  ");

   902 

   903     if (!awt_wm_atomInterned(&_XA_MOTIF_WM_INFO, "_MOTIF_WM_INFO")

   904         || !awt_wm_atomInterned(&_XA_DT_WORKSPACE_CURRENT, "_DT_WORKSPACE_CURRENT"))

   905     {

   906         return False;

   907     }

   908 

   909 

   910     status = XGetWindowProperty(awt_display, DefaultRootWindow(awt_display),

   911                  _XA_MOTIF_WM_INFO, 0, PROP_MOTIF_WM_INFO_ELEMENTS, False,

   912                  _XA_MOTIF_WM_INFO, &actual_type,

   913                  &actual_format, &nitems, &bytes_after,

   914                  (unsigned char **)&data);

   915 

   916     if (status != Success || data == NULL) {

   917         DTRACE_PRINTLN("no _MOTIF_WM_INFO on root");

   918         return False;

   919     }

   920 

   921     if (actual_type != _XA_MOTIF_WM_INFO || actual_format != 32

   922         || nitems != PROP_MOTIF_WM_INFO_ELEMENTS || bytes_after != 0)

   923     {

   924         DTRACE_PRINTLN("malformed _MOTIF_WM_INFO on root");

   925         XFree(data);            /* NULL data already catched above */

   926         return False;

   927     }

   928 

   929     /* NB: 64 bit: Cannot cast data to MotifWmInfo */

   930     wmwin = (Window)data[1];

   931     XFree(data);

   932 

   933     /* Now check that this window has _DT_WORKSPACE_CURRENT */

   934     curws = awt_getAtomListProperty(wmwin, _XA_DT_WORKSPACE_CURRENT, NULL);

   935     if (curws == NULL) {

   936         DTRACE_PRINTLN("no _DT_WORKSPACE_CURRENT");

   937         return False;

   938     }

   939 

   940     DTRACE_PRINTLN("yes");

   941     XFree(curws);

   942     return True;

   943 }

   944 

   945 

   946 static Boolean

   947 awt_wm_isNetWMName(char *name)

   948 {

   949     Window anchor;

   950     unsigned char *net_wm_name;

   951     Boolean matched;

   952 

   953     anchor = awt_wm_isNetSupporting();

   954     if (anchor == None) {

   955         return False;

   956     }

   957 

   958     DTRACE_PRINT1("WM: checking for %s by _NET_WM_NAME ...  ", name);

   959 

   960     /*

   961      * Check both UTF8_STRING and STRING.  We only call this function

   962      * with ASCII names and UTF8 preserves ASCII bit-wise.  wm-spec

   963      * mandates UTF8_STRING for _NET_WM_NAME but at least sawfish-1.0

   964      * still uses STRING.  (mmm, moving targets...).

   965      */

   966     net_wm_name = awt_getProperty8(anchor, _XA_NET_WM_NAME, XA_UTF8_STRING);

   967     if (net_wm_name == NULL) {

   968         net_wm_name = awt_getProperty8(anchor, _XA_NET_WM_NAME, XA_STRING);

   969     }

   970 

   971     if (net_wm_name == NULL) {

   972         DTRACE_PRINTLN("no (missing _NET_WM_NAME)");

   973         return False;

   974     }

   975 

   976     matched = (strcmp((char *)net_wm_name, name) == 0);

   977     if (matched) {

   978         DTRACE_PRINTLN("yes");

   979     } else {

   980         DTRACE_PRINTLN1("no (_NET_WM_NAME = \"%s\")", net_wm_name);

   981     }

   982     XFree(net_wm_name);

   983     return matched;

   984 }

   985 

   986 /*

   987  * Is Sawfish running?

   988  */

   989 static Boolean

   990 awt_wm_isSawfish(void)

   991 {

   992     return awt_wm_isNetWMName("Sawfish");

   993 }

   994 

   995 /*

   996  * Is KDE2 (KWin) running?

   997  */

   998 static Boolean

   999 awt_wm_isKDE2(void)

  1000 {

  1001     return awt_wm_isNetWMName("KWin");

  1002 }

  1003 

  1004 

  1005 /*

  1006  * Is Metacity running?

  1007  */

  1008 static Boolean

  1009 awt_wm_isMetacity(void)

  1010 {

  1011     return awt_wm_isNetWMName("Metacity");

  1012 }

  1013 

  1014 

  1015 /*

  1016  * Temporary error handler that ensures that we know if

  1017  * XChangeProperty succeeded or not.

  1018  */

  1019 static int /* but ignored */

  1020 xerror_verify_change_property(Display *dpy, XErrorEvent *err)

  1021 {

  1022     XERROR_SAVE(err);

  1023     if (err->request_code == X_ChangeProperty) {

  1024         return 0;

  1025     }

  1026     else {

  1027         return (*xerror_saved_handler)(dpy, err);

  1028     }

  1029 }

  1030 

  1031 

  1032 /*

  1033  * Prepare IceWM check.

  1034  *

  1035  * The only way to detect IceWM, seems to be by setting

  1036  * _ICEWM_WINOPTHINT(_ICEWM_WINOPTHINT/8) on root and checking if it

  1037  * was immediately deleted by IceWM.

  1038  *

  1039  * But messing with PropertyNotify here is way too much trouble, so

  1040  * approximate the check by setting the property in this function and

  1041  * checking if it still exists later on.

  1042  *

  1043  * Gaa, dirty dances...

  1044  */

  1045 static Boolean

  1046 awt_wm_prepareIsIceWM(void)

  1047 {

  1048     static Atom _XA_ICEWM_WINOPTHINT = None;

  1049 

  1050     /*

  1051      * Choose something innocuous: "AWT_ICEWM_TEST allWorkspaces 0".

  1052      * IceWM expects "class\0option\0arg\0" with zero bytes as delimiters.

  1053      */

  1054     static unsigned char opt[] = {

  1055         'A','W','T','_','I','C','E','W','M','_','T','E','S','T','\0',

  1056         'a','l','l','W','o','r','k','s','p','a','c','e','s','\0',

  1057         '0','\0'

  1058     };

  1059 

  1060     DTRACE_PRINT("WM: scheduling check for IceWM ...  ");

  1061 

  1062     if (!awt_wm_atomInterned(&_XA_ICEWM_WINOPTHINT, "_ICEWM_WINOPTHINT")) {

  1063         return False;

  1064     }

  1065 

  1066     WITH_XERROR_HANDLER(xerror_verify_change_property);

  1067     {

  1068         XChangeProperty(awt_display, DefaultRootWindow(awt_display),

  1069                         _XA_ICEWM_WINOPTHINT, _XA_ICEWM_WINOPTHINT, 8,

  1070                         PropModeReplace, opt, sizeof(opt));

  1071     }

  1072     RESTORE_XERROR_HANDLER;

  1073 

  1074     if (xerror_code != Success) {

  1075         DTRACE_PRINTLN1("can't set _ICEWM_WINOPTHINT, error = %d",

  1076                         xerror_code);

  1077         return False;

  1078     }

  1079     else {

  1080         DTRACE_PRINTLN("scheduled");

  1081         return True;

  1082     }

  1083 }

  1084 

  1085 /*

  1086  * Is IceWM running?

  1087  *

  1088  * Note well: Only call this if awt_wm_prepareIsIceWM succeeded, or a

  1089  * false positive will be reported.

  1090  */

  1091 static Boolean

  1092 awt_wm_isIceWM(void)

  1093 {

  1094     static Atom _XA_ICEWM_WINOPTHINT = None;

  1095 

  1096     /* Request status */

  1097     int status;

  1098 

  1099     /* Returns of XGetWindowProperty */

  1100     Atom actual_type;

  1101     int actual_format;

  1102     unsigned long nitems;

  1103     unsigned long bytes_after;

  1104     unsigned char *data;

  1105 

  1106     DTRACE_PRINT("WM: checking for IceWM ...  ");

  1107 

  1108     if (!awt_wm_atomInterned(&_XA_ICEWM_WINOPTHINT, "_ICEWM_WINOPTHINT")) {

  1109         return False;

  1110     }

  1111 

  1112     XGetWindowProperty(awt_display, DefaultRootWindow(awt_display),

  1113                  _XA_ICEWM_WINOPTHINT, 0, 0xFFFF, True, /* NB: deleting! */

  1114                  _XA_ICEWM_WINOPTHINT, &actual_type,

  1115                  &actual_format, &nitems, &bytes_after,

  1116                  &data);

  1117 

  1118     if (data != NULL) {

  1119         XFree(data);

  1120     }

  1121 

  1122     if (actual_type == None) {

  1123         DTRACE_PRINTLN("yes");

  1124         return True;

  1125     }

  1126     else {

  1127         DTRACE_PRINTLN("no");

  1128         return False;

  1129     }

  1130 }

  1131 

  1132 /*

  1133  * Is OpenLook WM running?

  1134  *