Actually move the kde files that were renamed in the last commit

1 files changed, 4645 insertions, 0 deletions

diff --git a/tdecore/netwm.cpp b/tdecore/netwm.cpp
new file mode 100644
index 000000000..455b6db65
--- /dev/null
+++ b/tdecore/netwm.cpp
@@ -0,0 +1,4645 @@
+/*
+
+  Copyright (c) 2000 Troll Tech AS
+  Copyright (c) 2003 Lubos Lunak <l.lunak@kde.org>
+
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the "Software"),
+  to deal in the Software without restriction, including without limitation
+  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+  and/or sell copies of the Software, and to permit persons to whom the
+  Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+  DEALINGS IN THE SOFTWARE.
+
+*/
+
+//#define NETWMDEBUG
+
+#include <tqwidget.h>
+#include <tqapplication.h>
+#ifdef Q_WS_X11 //FIXME
+
+#include "netwm.h"
+
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#include <X11/Xmd.h>
+
+#include "netwm_p.h"
+
+// UTF-8 string
+static Atom UTF8_STRING = 0;
+
+// root window properties
+static Atom net_supported            = 0;
+static Atom net_client_list          = 0;
+static Atom net_client_list_stacking = 0;
+static Atom net_desktop_geometry     = 0;
+static Atom net_desktop_viewport     = 0;
+static Atom net_current_desktop      = 0;
+static Atom net_desktop_names        = 0;
+static Atom net_number_of_desktops   = 0;
+static Atom net_active_window        = 0;
+static Atom net_workarea             = 0;
+static Atom net_supporting_wm_check  = 0;
+static Atom net_virtual_roots        = 0;
+static Atom net_showing_desktop      = 0;
+static Atom net_desktop_layout       = 0;
+
+// root window messages
+static Atom net_close_window         = 0;
+static Atom net_restack_window       = 0;
+static Atom net_wm_moveresize        = 0;
+static Atom net_moveresize_window    = 0;
+
+// application window properties
+static Atom net_wm_name              = 0;
+static Atom net_wm_visible_name      = 0;
+static Atom net_wm_icon_name         = 0;
+static Atom net_wm_visible_icon_name = 0;
+static Atom net_wm_desktop           = 0;
+static Atom net_wm_window_type       = 0;
+static Atom net_wm_state             = 0;
+static Atom net_wm_strut             = 0;
+static Atom net_wm_extended_strut    = 0; // the atom is called _NET_WM_STRUT_PARTIAL
+static Atom net_wm_icon_geometry     = 0;
+static Atom net_wm_icon              = 0;
+static Atom net_wm_pid               = 0;
+static Atom net_wm_user_time         = 0;
+static Atom net_wm_handled_icons     = 0;
+static Atom net_startup_id           = 0;
+static Atom net_wm_allowed_actions   = 0;
+static Atom wm_window_role           = 0;
+static Atom net_frame_extents        = 0;
+
+// KDE extensions
+static Atom kde_net_system_tray_windows       = 0;
+static Atom kde_net_wm_system_tray_window_for = 0;
+static Atom kde_net_wm_frame_strut            = 0;
+static Atom kde_net_wm_window_type_override   = 0;
+static Atom kde_net_wm_window_type_topmenu    = 0;
+static Atom kde_net_wm_temporary_rules        = 0;
+
+// application protocols
+static Atom wm_protocols = 0;
+static Atom net_wm_ping = 0;
+static Atom net_wm_take_activity = 0;
+
+// application window types
+static Atom net_wm_window_type_normal  = 0;
+static Atom net_wm_window_type_desktop = 0;
+static Atom net_wm_window_type_dock    = 0;
+static Atom net_wm_window_type_toolbar = 0;
+static Atom net_wm_window_type_menu    = 0;
+static Atom net_wm_window_type_dialog  = 0;
+static Atom net_wm_window_type_utility = 0;
+static Atom net_wm_window_type_splash  = 0;
+static Atom net_wm_window_type_dropdown_menu = 0;
+static Atom net_wm_window_type_popup_menu    = 0;
+static Atom net_wm_window_type_tooltip       = 0;
+static Atom net_wm_window_type_notification  = 0;
+static Atom net_wm_window_type_combobox      = 0;
+static Atom net_wm_window_type_dnd           = 0;
+
+// application window state
+static Atom net_wm_state_modal        = 0;
+static Atom net_wm_state_sticky       = 0;
+static Atom net_wm_state_max_vert     = 0;
+static Atom net_wm_state_max_horiz    = 0;
+static Atom net_wm_state_shaded       = 0;
+static Atom net_wm_state_skip_taskbar = 0;
+static Atom net_wm_state_skip_pager   = 0;
+static Atom net_wm_state_hidden       = 0;
+static Atom net_wm_state_fullscreen   = 0;
+static Atom net_wm_state_above        = 0;
+static Atom net_wm_state_below        = 0;
+static Atom net_wm_state_demands_attention = 0;
+
+// allowed actions
+static Atom net_wm_action_move        = 0;
+static Atom net_wm_action_resize      = 0;
+static Atom net_wm_action_minimize    = 0;
+static Atom net_wm_action_shade       = 0;
+static Atom net_wm_action_stick       = 0;
+static Atom net_wm_action_max_vert    = 0;
+static Atom net_wm_action_max_horiz   = 0;
+static Atom net_wm_action_fullscreen  = 0;
+static Atom net_wm_action_change_desk = 0;
+static Atom net_wm_action_close       = 0;
+
+// KDE extension that's not in the specs - Replaced by state_above now?
+static Atom net_wm_state_stays_on_top = 0;
+
+// used to determine whether application window is managed or not
+static Atom xa_wm_state = 0;
+
+// ability flags
+static Atom net_wm_full_placement = 0;
+
+static Bool netwm_atoms_created      = False;
+const unsigned long netwm_sendevent_mask = (SubstructureRedirectMask|
+					     SubstructureNotifyMask);
+
+
+const long MAX_PROP_SIZE = 100000;
+
+static char *nstrdup(const char *s1) {
+    if (! s1) return (char *) 0;
+
+    int l = strlen(s1) + 1;
+    char *s2 = new char[l];
+    strncpy(s2, s1, l);
+    return s2;
+}
+
+
+static char *nstrndup(const char *s1, int l) {
+    if (! s1 || l == 0) return (char *) 0;
+
+    char *s2 = new char[l+1];
+    strncpy(s2, s1, l);
+    s2[l] = '\0';
+    return s2;
+}
+
+
+static Window *nwindup(Window *w1, int n) {
+    if (! w1 || n == 0) return (Window *) 0;
+
+    Window *w2 = new Window[n];
+    while (n--)	w2[n] = w1[n];
+    return w2;
+}
+
+
+static void refdec_nri(NETRootInfoPrivate *p) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NET: decrementing NETRootInfoPrivate::ref (%d)\n", p->ref - 1);
+#endif
+
+    if (! --p->ref) {
+
+#ifdef    NETWMDEBUG
+	fprintf(stderr, "NET: \tno more references, deleting\n");
+#endif
+
+	delete [] p->name;
+	delete [] p->stacking;
+	delete [] p->clients;
+	delete [] p->virtual_roots;
+	delete [] p->kde_system_tray_windows;
+
+	int i;
+	for (i = 0; i < p->desktop_names.size(); i++)
+	    delete [] p->desktop_names[i];
+    }
+}
+
+
+static void refdec_nwi(NETWinInfoPrivate *p) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NET: decrementing NETWinInfoPrivate::ref (%d)\n", p->ref - 1);
+#endif
+
+    if (! --p->ref) {
+
+#ifdef    NETWMDEBUG
+	fprintf(stderr, "NET: \tno more references, deleting\n");
+#endif
+
+	delete [] p->name;
+	delete [] p->visible_name;
+	delete [] p->icon_name;
+	delete [] p->visible_icon_name;
+	delete [] p->startup_id;
+
+	int i;
+	for (i = 0; i < p->icons.size(); i++)
+	    delete [] p->icons[i].data;
+    }
+}
+
+
+static int wcmp(const void *a, const void *b) {
+    return *((Window *) a) - *((Window *) b);
+}
+
+
+static const int netAtomCount = 85;
+static void create_atoms(Display *d) {
+    static const char * const names[netAtomCount] =
+    {
+	"UTF8_STRING",
+	    "_NET_SUPPORTED",
+	    "_NET_SUPPORTING_WM_CHECK",
+	    "_NET_CLIENT_LIST",
+	    "_NET_CLIENT_LIST_STACKING",
+	    "_NET_NUMBER_OF_DESKTOPS",
+	    "_NET_DESKTOP_GEOMETRY",
+	    "_NET_DESKTOP_VIEWPORT",
+	    "_NET_CURRENT_DESKTOP",
+	    "_NET_DESKTOP_NAMES",
+	    "_NET_ACTIVE_WINDOW",
+	    "_NET_WORKAREA",
+	    "_NET_VIRTUAL_ROOTS",
+            "_NET_DESKTOP_LAYOUT",
+            "_NET_SHOWING_DESKTOP",
+	    "_NET_CLOSE_WINDOW",
+            "_NET_RESTACK_WINDOW",
+
+	    "_NET_WM_MOVERESIZE",
+            "_NET_MOVERESIZE_WINDOW",
+	    "_NET_WM_NAME",
+	    "_NET_WM_VISIBLE_NAME",
+	    "_NET_WM_ICON_NAME",
+	    "_NET_WM_VISIBLE_ICON_NAME",
+	    "_NET_WM_DESKTOP",
+	    "_NET_WM_WINDOW_TYPE",
+	    "_NET_WM_STATE",
+	    "_NET_WM_STRUT",
+            "_NET_WM_STRUT_PARTIAL",
+	    "_NET_WM_ICON_GEOMETRY",
+	    "_NET_WM_ICON",
+	    "_NET_WM_PID",
+	    "_NET_WM_USER_TIME",
+	    "_NET_WM_HANDLED_ICONS",
+            "_NET_STARTUP_ID",
+            "_NET_WM_ALLOWED_ACTIONS",
+	    "_NET_WM_PING",
+            "_NET_WM_TAKE_ACTIVITY",
+            "WM_WINDOW_ROLE",
+            "_NET_FRAME_EXTENTS",
+
+	    "_NET_WM_WINDOW_TYPE_NORMAL",
+	    "_NET_WM_WINDOW_TYPE_DESKTOP",
+	    "_NET_WM_WINDOW_TYPE_DOCK",
+	    "_NET_WM_WINDOW_TYPE_TOOLBAR",
+	    "_NET_WM_WINDOW_TYPE_MENU",
+	    "_NET_WM_WINDOW_TYPE_DIALOG",
+	    "_NET_WM_WINDOW_TYPE_UTILITY",
+	    "_NET_WM_WINDOW_TYPE_SPLASH",
+	    "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU",
+	    "_NET_WM_WINDOW_TYPE_POPUP_MENU",
+	    "_NET_WM_WINDOW_TYPE_TOOLTIP",
+	    "_NET_WM_WINDOW_TYPE_NOTIFICATION",
+	    "_NET_WM_WINDOW_TYPE_COMBOBOX",
+	    "_NET_WM_WINDOW_TYPE_DND",
+
+	    "_NET_WM_STATE_MODAL",
+	    "_NET_WM_STATE_STICKY",
+	    "_NET_WM_STATE_MAXIMIZED_VERT",
+	    "_NET_WM_STATE_MAXIMIZED_HORZ",
+	    "_NET_WM_STATE_SHADED",
+	    "_NET_WM_STATE_SKIP_TASKBAR",
+	    "_NET_WM_STATE_SKIP_PAGER",
+	    "_NET_WM_STATE_HIDDEN",
+	    "_NET_WM_STATE_FULLSCREEN",
+	    "_NET_WM_STATE_ABOVE",
+	    "_NET_WM_STATE_BELOW",
+	    "_NET_WM_STATE_DEMANDS_ATTENTION",
+
+            "_NET_WM_ACTION_MOVE",
+            "_NET_WM_ACTION_RESIZE",
+            "_NET_WM_ACTION_MINIMIZE",
+            "_NET_WM_ACTION_SHADE",
+            "_NET_WM_ACTION_STICK",
+            "_NET_WM_ACTION_MAXIMIZE_VERT",
+            "_NET_WM_ACTION_MAXIMIZE_HORZ",
+            "_NET_WM_ACTION_FULLSCREEN",
+            "_NET_WM_ACTION_CHANGE_DESKTOP",
+            "_NET_WM_ACTION_CLOSE",
+
+	    "_NET_WM_STATE_STAYS_ON_TOP",
+
+	    "_KDE_NET_SYSTEM_TRAY_WINDOWS",
+	    "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR",
+	    "_KDE_NET_WM_FRAME_STRUT",
+	    "_KDE_NET_WM_WINDOW_TYPE_OVERRIDE",
+	    "_KDE_NET_WM_WINDOW_TYPE_TOPMENU",
+            "_KDE_NET_WM_TEMPORARY_RULES",
+
+	    "WM_STATE",
+	    "WM_PROTOCOLS",
+            
+            "_NET_WM_FULL_PLACEMENT"
+	    };
+
+    Atom atoms[netAtomCount], *atomsp[netAtomCount] =
+    {
+	&UTF8_STRING,
+	    &net_supported,
+	    &net_supporting_wm_check,
+	    &net_client_list,
+	    &net_client_list_stacking,
+	    &net_number_of_desktops,
+	    &net_desktop_geometry,
+	    &net_desktop_viewport,
+	    &net_current_desktop,
+	    &net_desktop_names,
+	    &net_active_window,
+	    &net_workarea,
+	    &net_virtual_roots,
+            &net_desktop_layout,
+            &net_showing_desktop,
+	    &net_close_window,
+            &net_restack_window,
+
+	    &net_wm_moveresize,
+            &net_moveresize_window,
+	    &net_wm_name,
+	    &net_wm_visible_name,
+	    &net_wm_icon_name,
+	    &net_wm_visible_icon_name,
+	    &net_wm_desktop,
+	    &net_wm_window_type,
+	    &net_wm_state,
+	    &net_wm_strut,
+            &net_wm_extended_strut,
+	    &net_wm_icon_geometry,
+	    &net_wm_icon,
+	    &net_wm_pid,
+	    &net_wm_user_time,
+	    &net_wm_handled_icons,
+            &net_startup_id,
+            &net_wm_allowed_actions,
+	    &net_wm_ping,
+            &net_wm_take_activity,
+            &wm_window_role,
+            &net_frame_extents,
+
+	    &net_wm_window_type_normal,
+	    &net_wm_window_type_desktop,
+	    &net_wm_window_type_dock,
+	    &net_wm_window_type_toolbar,
+	    &net_wm_window_type_menu,
+	    &net_wm_window_type_dialog,
+	    &net_wm_window_type_utility,
+	    &net_wm_window_type_splash,
+	    &net_wm_window_type_dropdown_menu,
+	    &net_wm_window_type_popup_menu,
+	    &net_wm_window_type_tooltip,
+	    &net_wm_window_type_notification,
+	    &net_wm_window_type_combobox,
+	    &net_wm_window_type_dnd,
+
+	    &net_wm_state_modal,
+	    &net_wm_state_sticky,
+	    &net_wm_state_max_vert,
+	    &net_wm_state_max_horiz,
+	    &net_wm_state_shaded,
+	    &net_wm_state_skip_taskbar,
+	    &net_wm_state_skip_pager,
+	    &net_wm_state_hidden,
+	    &net_wm_state_fullscreen,
+	    &net_wm_state_above,
+	    &net_wm_state_below,
+	    &net_wm_state_demands_attention,
+
+            &net_wm_action_move,
+            &net_wm_action_resize,
+            &net_wm_action_minimize,
+            &net_wm_action_shade,
+            &net_wm_action_stick,
+            &net_wm_action_max_vert,
+            &net_wm_action_max_horiz,
+            &net_wm_action_fullscreen,
+            &net_wm_action_change_desk,
+            &net_wm_action_close,
+
+	    &net_wm_state_stays_on_top,
+
+	    &kde_net_system_tray_windows,
+	    &kde_net_wm_system_tray_window_for,
+	    &kde_net_wm_frame_strut,
+	    &kde_net_wm_window_type_override,
+	    &kde_net_wm_window_type_topmenu,
+            &kde_net_wm_temporary_rules,
+
+	    &xa_wm_state,
+	    &wm_protocols,
+            
+            &net_wm_full_placement
+	    };
+
+    assert( !netwm_atoms_created );
+
+    int i = netAtomCount;
+    while (i--)
+	atoms[i] = 0;
+
+    XInternAtoms(d, (char **) names, netAtomCount, False, atoms);
+
+    i = netAtomCount;
+    while (i--)
+	*atomsp[i] = atoms[i];
+
+    netwm_atoms_created = True;
+}
+
+
+static void readIcon(Display* display, Window window, Atom property, NETRArray<NETIcon>& icons, int& icon_count) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NET: readIcon\n");
+#endif
+
+    Atom type_ret;
+    int format_ret;
+    unsigned long nitems_ret = 0, after_ret = 0;
+    unsigned char *data_ret = 0;
+
+    // reset
+    for (int i = 0; i < icons.size(); i++)
+        delete [] icons[i].data;
+    icons.reset();
+    icon_count = 0;
+
+    // allocate buffers
+    unsigned char *buffer = 0;
+    unsigned long offset = 0;
+    unsigned long buffer_offset = 0;
+    unsigned long bufsize = 0;
+
+    // read data
+    do {
+	if (XGetWindowProperty(display, window, property, offset,
+			       MAX_PROP_SIZE, False, XA_CARDINAL, &type_ret,
+			       &format_ret, &nitems_ret, &after_ret, &data_ret)
+	    == Success) {
+            if (!bufsize)
+            {
+               if (nitems_ret < 3 || type_ret != XA_CARDINAL ||
+                  format_ret != 32) {
+                  // either we didn't get the property, or the property has less than
+                  // 3 elements in it
+                  // NOTE: 3 is the ABSOLUTE minimum:
+                  //     width = 1, height = 1, length(data) = 1 (width * height)
+                  if ( data_ret )
+                     XFree(data_ret);
+                  return;
+               }
+
+               bufsize = nitems_ret * sizeof(long) + after_ret;
+               buffer = (unsigned char *) malloc(bufsize);
+            }
+            else if (buffer_offset + nitems_ret*sizeof(long) > bufsize)
+            {
+fprintf(stderr, "NETWM: Warning readIcon() needs buffer adjustment!\n");
+               bufsize = buffer_offset + nitems_ret * sizeof(long) + after_ret;
+               buffer = (unsigned char *) realloc(buffer, bufsize);
+            }
+	    memcpy((buffer + buffer_offset), data_ret, nitems_ret * sizeof(long));
+	    buffer_offset += nitems_ret * sizeof(long);
+	    offset += nitems_ret;
+
+	    if ( data_ret )
+		XFree(data_ret);
+	} else {
+            if (buffer)
+               free(buffer);
+	    return; // Some error occurred cq. property didn't exist.
+	}
+    }
+    while (after_ret > 0);
+
+    CARD32 *data32;
+    unsigned long i, j, k, sz, s;
+    unsigned long *d = (unsigned long *) buffer;
+    for (i = 0, j = 0; i < bufsize;) {
+	icons[j].size.width = *d++;
+	i += sizeof(long);
+	icons[j].size.height = *d++;
+	i += sizeof(long);
+
+	sz = icons[j].size.width * icons[j].size.height;
+	s = sz * sizeof(long);
+
+	if ( i + s - 1 > bufsize || sz == 0 || sz > 1024 * 1024 ) {
+	    break;
+	}
+
+	delete [] icons[j].data;
+	data32 = new CARD32[sz];
+	icons[j].data = (unsigned char *) data32;
+	for (k = 0; k < sz; k++, i += sizeof(long)) {
+	    *data32++ = (CARD32) *d++;
+	}
+	j++;
+        icon_count++;
+    }
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NET: readIcon got %d icons\n", icon_count);
+#endif
+
+    free(buffer);
+}
+
+
+template <class Z>
+NETRArray<Z>::NETRArray()
+  : sz(0),  capacity(2)
+{
+    d = (Z*) calloc(capacity, sizeof(Z)); // allocate 2 elts and set to zero
+}
+
+
+template <class Z>
+NETRArray<Z>::~NETRArray() {
+    free(d);
+}
+
+
+template <class Z>
+void NETRArray<Z>::reset() {
+    sz = 0;
+    capacity = 2;
+    d = (Z*) realloc(d, sizeof(Z)*capacity);
+    memset( (void*) d, 0, sizeof(Z)*capacity );
+}
+
+template <class Z>
+Z &NETRArray<Z>::operator[](int index) {
+    if (index >= capacity) {
+	// allocate space for the new data
+	// open table has amortized O(1) access time
+	// when N elements appended consecutively -- exa
+        int newcapacity = 2*capacity > index+1 ? 2*capacity : index+1; // max
+	// copy into new larger memory block using realloc
+        d = (Z*) realloc(d, sizeof(Z)*newcapacity);
+        memset( (void*) &d[capacity], 0, sizeof(Z)*(newcapacity-capacity) );
+	capacity = newcapacity;
+    }
+    if (index >= sz)            // at this point capacity>index
+        sz = index + 1;
+
+    return d[index];
+}
+
+
+// Construct a new NETRootInfo object.
+
+NETRootInfo::NETRootInfo(Display *display, Window supportWindow, const char *wmName,
+			 const unsigned long properties[], int properties_size,
+                         int screen, bool doActivate)
+{
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::NETRootInfo: using window manager constructor\n");
+#endif
+
+    p = new NETRootInfoPrivate;
+    p->ref = 1;
+
+    p->display = display;
+    p->name = nstrdup(wmName);
+
+    if (screen != -1) {
+	p->screen = screen;
+    } else {
+	p->screen = DefaultScreen(p->display);
+    }
+
+    p->root = RootWindow(p->display, p->screen);
+    p->supportwindow = supportWindow;
+    p->number_of_desktops = p->current_desktop = 0;
+    p->active = None;
+    p->clients = p->stacking = p->virtual_roots = (Window *) 0;
+    p->clients_count = p->stacking_count = p->virtual_roots_count = 0;
+    p->kde_system_tray_windows = 0;
+    p->kde_system_tray_windows_count = 0;
+    p->showing_desktop = false;
+    p->desktop_layout_orientation = OrientationHorizontal;
+    p->desktop_layout_corner = DesktopLayoutCornerTopLeft;
+    p->desktop_layout_columns = p->desktop_layout_rows = 0;
+    setDefaultProperties();
+    if( properties_size > PROPERTIES_SIZE ) {
+        fprintf( stderr, "NETRootInfo::NETRootInfo(): properties array too large\n");
+        properties_size = PROPERTIES_SIZE;
+    }
+    for( int i = 0; i < properties_size; ++i )
+        p->properties[ i ] = properties[ i ];
+    // force support for Supported and SupportingWMCheck for window managers
+    p->properties[ PROTOCOLS ] |= ( Supported | SupportingWMCheck );
+    p->client_properties[ PROTOCOLS ] = DesktopNames // the only thing that can be changed by clients
+			                | WMPing; // or they can reply to this
+    p->client_properties[ PROTOCOLS2 ] = WM2TakeActivity | WM2DesktopLayout;
+
+    role = WindowManager;
+
+    if (! netwm_atoms_created) create_atoms(p->display);
+
+    if (doActivate) activate();
+}
+
+NETRootInfo::NETRootInfo(Display *display, Window supportWindow, const char *wmName,
+			 unsigned long properties, int screen, bool doActivate)
+{
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::NETRootInfo: using window manager constructor\n");
+#endif
+
+    p = new NETRootInfoPrivate;
+    p->ref = 1;
+
+    p->display = display;
+    p->name = nstrdup(wmName);
+
+    if (screen != -1) {
+	p->screen = screen;
+    } else {
+	p->screen = DefaultScreen(p->display);
+    }
+
+    p->root = RootWindow(p->display, p->screen);
+    p->supportwindow = supportWindow;
+    p->number_of_desktops = p->current_desktop = 0;
+    p->active = None;
+    p->clients = p->stacking = p->virtual_roots = (Window *) 0;
+    p->clients_count = p->stacking_count = p->virtual_roots_count = 0;
+    p->kde_system_tray_windows = 0;
+    p->kde_system_tray_windows_count = 0;
+    p->showing_desktop = false;
+    setDefaultProperties();
+    p->properties[ PROTOCOLS ] = properties;
+    // force support for Supported and SupportingWMCheck for window managers
+    p->properties[ PROTOCOLS ] |= ( Supported | SupportingWMCheck );
+    p->client_properties[ PROTOCOLS ] = DesktopNames // the only thing that can be changed by clients
+			                | WMPing; // or they can reply to this
+    p->client_properties[ PROTOCOLS2 ] = WM2TakeActivity;
+
+    role = WindowManager;
+
+    if (! netwm_atoms_created) create_atoms(p->display);
+
+    if (doActivate) activate();
+}
+
+
+NETRootInfo::NETRootInfo(Display *display, const unsigned long properties[], int properties_size,
+                         int screen, bool doActivate)
+{
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::NETRootInfo: using Client constructor\n");
+#endif
+
+    p = new NETRootInfoPrivate;
+    p->ref = 1;
+
+    p->name = 0;
+
+    p->display = display;
+
+    if (screen != -1) {
+	p->screen = screen;
+    } else {
+	p->screen = DefaultScreen(p->display);
+    }
+
+    p->root = RootWindow(p->display, p->screen);
+    p->rootSize.width = WidthOfScreen(ScreenOfDisplay(p->display, p->screen));
+    p->rootSize.height = HeightOfScreen(ScreenOfDisplay(p->display, p->screen));
+
+    p->supportwindow = None;
+    p->number_of_desktops = p->current_desktop = 0;
+    p->active = None;
+    p->clients = p->stacking = p->virtual_roots = (Window *) 0;
+    p->clients_count = p->stacking_count = p->virtual_roots_count = 0;
+    p->kde_system_tray_windows = 0;
+    p->kde_system_tray_windows_count = 0;
+    p->showing_desktop = false;
+    p->desktop_layout_orientation = OrientationHorizontal;
+    p->desktop_layout_corner = DesktopLayoutCornerTopLeft;
+    p->desktop_layout_columns = p->desktop_layout_rows = 0;
+    setDefaultProperties();
+    if( properties_size > 2 ) {
+        fprintf( stderr, "NETWinInfo::NETWinInfo(): properties array too large\n");
+        properties_size = 2;
+    }
+    for( int i = 0; i < properties_size; ++i )
+        // remap from [0]=NET::Property,[1]=NET::Property2
+        switch( i ) {
+            case 0:
+                p->client_properties[ PROTOCOLS ] = properties[ i ];
+                break;
+            case 1:
+                p->client_properties[ PROTOCOLS2 ] = properties[ i ];
+                break;
+        }
+    for( int i = 0; i < PROPERTIES_SIZE; ++i )
+        p->properties[ i ] = 0;
+
+    role = Client;
+
+    if (! netwm_atoms_created) create_atoms(p->display);
+
+    if (doActivate) activate();
+}
+
+NETRootInfo::NETRootInfo(Display *display, unsigned long properties, int screen,
+			 bool doActivate)
+{
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::NETRootInfo: using Client constructor\n");
+#endif
+
+    p = new NETRootInfoPrivate;
+    p->ref = 1;
+
+    p->name = 0;
+
+    p->display = display;
+
+    if (screen != -1) {
+	p->screen = screen;
+    } else {
+	p->screen = DefaultScreen(p->display);
+    }
+
+    p->root = RootWindow(p->display, p->screen);
+    p->rootSize.width = WidthOfScreen(ScreenOfDisplay(p->display, p->screen));
+    p->rootSize.height = HeightOfScreen(ScreenOfDisplay(p->display, p->screen));
+
+    p->supportwindow = None;
+    p->number_of_desktops = p->current_desktop = 0;
+    p->active = None;
+    p->clients = p->stacking = p->virtual_roots = (Window *) 0;
+    p->clients_count = p->stacking_count = p->virtual_roots_count = 0;
+    p->kde_system_tray_windows = 0;
+    p->kde_system_tray_windows_count = 0;
+    p->showing_desktop = false;
+    p->desktop_layout_orientation = OrientationHorizontal;
+    p->desktop_layout_corner = DesktopLayoutCornerTopLeft;
+    p->desktop_layout_columns = p->desktop_layout_rows = 0;
+    setDefaultProperties();
+    p->client_properties[ PROTOCOLS ] = properties;
+    for( int i = 0; i < PROPERTIES_SIZE; ++i )
+        p->properties[ i ] = 0;
+
+    role = Client;
+
+    if (! netwm_atoms_created) create_atoms(p->display);
+
+    if (doActivate) activate();
+}
+
+
+NETRootInfo2::NETRootInfo2(Display *display, Window supportWindow, const char *wmName,
+			 unsigned long properties[], int properties_size,
+                         int screen, bool doActivate)
+    : NETRootInfo( display, supportWindow, wmName, properties, properties_size,
+	screen, doActivate )
+{
+}
+
+NETRootInfo2::NETRootInfo2(Display *display, const unsigned long properties[], int properties_size,
+                int screen, bool doActivate)
+    : NETRootInfo( display, properties, properties_size, screen, doActivate )
+{
+}
+
+NETRootInfo3::NETRootInfo3(Display *display, Window supportWindow, const char *wmName,
+			 unsigned long properties[], int properties_size,
+                         int screen, bool doActivate)
+    : NETRootInfo2( display, supportWindow, wmName, properties, properties_size,
+	screen, doActivate )
+{
+}
+
+NETRootInfo3::NETRootInfo3(Display *display, const unsigned long properties[], int properties_size,
+                int screen, bool doActivate)
+    : NETRootInfo2( display, properties, properties_size, screen, doActivate )
+{
+}
+
+NETRootInfo4::NETRootInfo4(Display *display, Window supportWindow, const char *wmName,
+			 unsigned long properties[], int properties_size,
+                         int screen, bool doActivate)
+    : NETRootInfo3( display, supportWindow, wmName, properties, properties_size,
+	screen, doActivate )
+{
+}
+
+NETRootInfo4::NETRootInfo4(Display *display, const unsigned long properties[], int properties_size,
+                int screen, bool doActivate)
+    : NETRootInfo3( display, properties, properties_size, screen, doActivate )
+{
+}
+
+// Copy an existing NETRootInfo object.
+
+NETRootInfo::NETRootInfo(const NETRootInfo &rootinfo) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::NETRootInfo: using copy constructor\n");
+#endif
+
+    p = rootinfo.p;
+    role = rootinfo.role;
+
+    p->ref++;
+}
+
+
+// Be gone with our NETRootInfo.
+
+NETRootInfo::~NETRootInfo() {
+    refdec_nri(p);
+
+    if (! p->ref) delete p;
+}
+
+
+void NETRootInfo::setDefaultProperties()
+{
+    p->properties[ PROTOCOLS ] = Supported | SupportingWMCheck;
+    p->properties[ WINDOW_TYPES ] = NormalMask | DesktopMask | DockMask
+        | ToolbarMask | MenuMask | DialogMask;
+    p->properties[ STATES ] = Modal | Sticky | MaxVert | MaxHoriz | Shaded
+        | SkipTaskbar | StaysOnTop;
+    p->properties[ PROTOCOLS2 ] = 0;
+    p->properties[ ACTIONS ] = 0;
+    p->client_properties[ PROTOCOLS ] = 0;
+    p->client_properties[ WINDOW_TYPES ] = 0; // these two actually don't
+    p->client_properties[ STATES ] = 0;       // make sense in client_properties
+    p->client_properties[ PROTOCOLS2 ] = 0;
+    p->client_properties[ ACTIONS ] = 0;
+}
+
+void NETRootInfo::activate() {
+    if (role == WindowManager) {
+
+#ifdef    NETWMDEBUG
+	fprintf(stderr,
+		"NETRootInfo::activate: setting supported properties on root\n");
+#endif
+
+	setSupported();
+	update(p->client_properties);
+    } else {
+
+#ifdef    NETWMDEBUG
+	fprintf(stderr, "NETRootInfo::activate: updating client information\n");
+#endif
+
+	update(p->client_properties);
+    }
+}
+
+
+void NETRootInfo::setClientList(Window *windows, unsigned int count) {
+    if (role != WindowManager) return;
+
+    p->clients_count = count;
+
+    delete [] p->clients;
+    p->clients = nwindup(windows, count);
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::setClientList: setting list with %ld windows\n",
+	    p->clients_count);
+#endif
+
+    XChangeProperty(p->display, p->root, net_client_list, XA_WINDOW, 32,
+		    PropModeReplace, (unsigned char *)p->clients,
+		    p->clients_count);
+}
+
+
+void NETRootInfo::setClientListStacking(Window *windows, unsigned int count) {
+    if (role != WindowManager) return;
+
+    p->stacking_count = count;
+    delete [] p->stacking;
+    p->stacking = nwindup(windows, count);
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr,
+	    "NETRootInfo::setClientListStacking: setting list with %ld windows\n",
+	    p->clients_count);
+#endif
+
+    XChangeProperty(p->display, p->root, net_client_list_stacking, XA_WINDOW, 32,
+		    PropModeReplace, (unsigned char *) p->stacking,
+		    p->stacking_count);
+}
+
+
+void NETRootInfo::setKDESystemTrayWindows(Window *windows, unsigned int count) {
+    if (role != WindowManager) return;
+
+    p->kde_system_tray_windows_count = count;
+    delete [] p->kde_system_tray_windows;
+    p->kde_system_tray_windows = nwindup(windows, count);
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr,
+	    "NETRootInfo::setKDESystemTrayWindows: setting list with %ld windows\n",
+	    p->kde_system_tray_windows_count);
+#endif
+
+    XChangeProperty(p->display, p->root, kde_net_system_tray_windows, XA_WINDOW, 32,
+		    PropModeReplace,
+		    (unsigned char *) p->kde_system_tray_windows,
+		    p->kde_system_tray_windows_count);
+}
+
+
+void NETRootInfo::setNumberOfDesktops(int numberOfDesktops) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr,
+	    "NETRootInfo::setNumberOfDesktops: setting desktop count to %d (%s)\n",
+	    numberOfDesktops, (role == WindowManager) ? "WM" : "Client");
+#endif
+
+    if (role == WindowManager) {
+	p->number_of_desktops = numberOfDesktops;
+ 	long d = numberOfDesktops;
+	XChangeProperty(p->display, p->root, net_number_of_desktops, XA_CARDINAL, 32,
+			PropModeReplace, (unsigned char *) &d, 1);
+    } else {
+	XEvent e;
+
+	e.xclient.type = ClientMessage;
+	e.xclient.message_type = net_number_of_desktops;
+	e.xclient.display = p->display;
+	e.xclient.window = p->root;
+	e.xclient.format = 32;
+	e.xclient.data.l[0] = numberOfDesktops;
+	e.xclient.data.l[1] = 0l;
+	e.xclient.data.l[2] = 0l;
+	e.xclient.data.l[3] = 0l;
+	e.xclient.data.l[4] = 0l;
+
+	XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+    }
+}
+
+
+void NETRootInfo::setCurrentDesktop(int desktop) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr,
+	    "NETRootInfo::setCurrentDesktop: setting current desktop = %d (%s)\n",
+	    desktop, (role == WindowManager) ? "WM" : "Client");
+#endif
+
+    if (role == WindowManager) {
+	p->current_desktop = desktop;
+	long d = p->current_desktop - 1;
+	XChangeProperty(p->display, p->root, net_current_desktop, XA_CARDINAL, 32,
+			PropModeReplace, (unsigned char *) &d, 1);
+    } else {
+	XEvent e;
+
+	e.xclient.type = ClientMessage;
+	e.xclient.message_type = net_current_desktop;
+	e.xclient.display = p->display;
+	e.xclient.window = p->root;
+	e.xclient.format = 32;
+	e.xclient.data.l[0] = desktop - 1;
+	e.xclient.data.l[1] = 0l;
+	e.xclient.data.l[2] = 0l;
+	e.xclient.data.l[3] = 0l;
+	e.xclient.data.l[4] = 0l;
+
+	XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+    }
+}
+
+
+void NETRootInfo::setDesktopName(int desktop, const char *desktopName) {
+    // allow setting desktop names even for non-existant desktops, see the spec, sect.3.7.
+    if (desktop < 1) return;
+
+    delete [] p->desktop_names[desktop - 1];
+    p->desktop_names[desktop - 1] = nstrdup(desktopName);
+
+    unsigned int i, proplen,
+	num = ((p->number_of_desktops > p->desktop_names.size()) ?
+	       p->number_of_desktops : p->desktop_names.size());
+    for (i = 0, proplen = 0; i < num; i++)
+	proplen += (p->desktop_names[i] != 0 ? strlen(p->desktop_names[i])+1 : 1 );
+
+    char *prop = new char[proplen], *propp = prop;
+
+    for (i = 0; i < num; i++)
+	if (p->desktop_names[i]) {
+	    strcpy(propp, p->desktop_names[i]);
+	    propp += strlen(p->desktop_names[i]) + 1;
+	} else
+	    *propp++ = '\0';
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr,
+	    "NETRootInfo::setDesktopName(%d, '%s')\n"
+	    "NETRootInfo::setDesktopName: total property length = %d",
+	    desktop, desktopName, proplen);
+#endif
+
+    XChangeProperty(p->display, p->root, net_desktop_names, UTF8_STRING, 8,
+		    PropModeReplace, (unsigned char *) prop, proplen);
+
+    delete [] prop;
+}
+
+
+void NETRootInfo::setDesktopGeometry(int , const NETSize &geometry) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::setDesktopGeometry( -- , { %d, %d }) (%s)\n",
+	    geometry.width, geometry.height, (role == WindowManager) ? "WM" : "Client");
+#endif
+
+    if (role == WindowManager) {
+	p->geometry = geometry;
+
+	long data[2];
+	data[0] = p->geometry.width;
+	data[1] = p->geometry.height;
+
+	XChangeProperty(p->display, p->root, net_desktop_geometry, XA_CARDINAL, 32,
+			PropModeReplace, (unsigned char *) data, 2);
+    } else {
+	XEvent e;
+
+	e.xclient.type = ClientMessage;
+	e.xclient.message_type = net_desktop_geometry;
+	e.xclient.display = p->display;
+	e.xclient.window = p->root;
+	e.xclient.format = 32;
+	e.xclient.data.l[0] = geometry.width;
+	e.xclient.data.l[1] = geometry.height;
+	e.xclient.data.l[2] = 0l;
+	e.xclient.data.l[3] = 0l;
+	e.xclient.data.l[4] = 0l;
+
+	XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+    }
+}
+
+
+void NETRootInfo::setDesktopViewport(int desktop, const NETPoint &viewport) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::setDesktopViewport(%d, { %d, %d }) (%s)\n",
+	    desktop, viewport.x, viewport.y, (role == WindowManager) ? "WM" : "Client");
+#endif
+
+    if (desktop < 1) return;
+
+    if (role == WindowManager) {
+	p->viewport[desktop - 1] = viewport;
+
+	int d, i, l;
+	l = p->number_of_desktops * 2;
+	long *data = new long[l];
+	for (d = 0, i = 0; d < p->number_of_desktops; d++) {
+	    data[i++] = p->viewport[d].x;
+	    data[i++] = p->viewport[d].y;
+	}
+
+	XChangeProperty(p->display, p->root, net_desktop_viewport, XA_CARDINAL, 32,
+			PropModeReplace, (unsigned char *) data, l);
+
+	delete [] data;
+    } else {
+	XEvent e;
+
+	e.xclient.type = ClientMessage;
+	e.xclient.message_type = net_desktop_viewport;
+	e.xclient.display = p->display;
+	e.xclient.window = p->root;
+	e.xclient.format = 32;
+	e.xclient.data.l[0] = viewport.x;
+	e.xclient.data.l[1] = viewport.y;
+	e.xclient.data.l[2] = 0l;
+	e.xclient.data.l[3] = 0l;
+	e.xclient.data.l[4] = 0l;
+
+	XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+    }
+}
+
+
+void NETRootInfo::setSupported() {
+    if (role != WindowManager) {
+#ifdef    NETWMDEBUG
+	fprintf(stderr, "NETRootInfo::setSupported - role != WindowManager\n");
+#endif
+
+	return;
+    }
+
+    Atom atoms[netAtomCount];
+    int pnum = 2;
+
+    // Root window properties/messages
+    atoms[0] = net_supported;
+    atoms[1] = net_supporting_wm_check;
+
+    if (p->properties[ PROTOCOLS ] & ClientList)
+	atoms[pnum++] = net_client_list;
+
+    if (p->properties[ PROTOCOLS ] & ClientListStacking)
+	atoms[pnum++] = net_client_list_stacking;
+
+    if (p->properties[ PROTOCOLS ] & NumberOfDesktops)
+	atoms[pnum++] = net_number_of_desktops;
+
+    if (p->properties[ PROTOCOLS ] & DesktopGeometry)
+	atoms[pnum++] = net_desktop_geometry;
+
+    if (p->properties[ PROTOCOLS ] & DesktopViewport)
+	atoms[pnum++] = net_desktop_viewport;
+
+    if (p->properties[ PROTOCOLS ] & CurrentDesktop)
+	atoms[pnum++] = net_current_desktop;
+
+    if (p->properties[ PROTOCOLS ] & DesktopNames)
+	atoms[pnum++] = net_desktop_names;
+
+    if (p->properties[ PROTOCOLS ] & ActiveWindow)
+	atoms[pnum++] = net_active_window;
+
+    if (p->properties[ PROTOCOLS ] & WorkArea)
+	atoms[pnum++] = net_workarea;
+
+    if (p->properties[ PROTOCOLS ] & VirtualRoots)
+	atoms[pnum++] = net_virtual_roots;
+
+    if (p->properties[ PROTOCOLS2 ] & WM2DesktopLayout)
+	atoms[pnum++] = net_desktop_layout;
+
+    if (p->properties[ PROTOCOLS ] & CloseWindow)
+	atoms[pnum++] = net_close_window;
+
+    if (p->properties[ PROTOCOLS2 ] & WM2RestackWindow)
+	atoms[pnum++] = net_restack_window;
+
+    if (p->properties[ PROTOCOLS2 ] & WM2ShowingDesktop)
+	atoms[pnum++] = net_showing_desktop;
+
+    // Application window properties/messages
+    if (p->properties[ PROTOCOLS ] & WMMoveResize)
+	atoms[pnum++] = net_wm_moveresize;
+
+    if (p->properties[ PROTOCOLS2 ] & WM2MoveResizeWindow)
+	atoms[pnum++] = net_moveresize_window;
+
+    if (p->properties[ PROTOCOLS ] & WMName)
+	atoms[pnum++] = net_wm_name;
+
+    if (p->properties[ PROTOCOLS ] & WMVisibleName)
+	atoms[pnum++] = net_wm_visible_name;
+
+    if (p->properties[ PROTOCOLS ] & WMIconName)
+	atoms[pnum++] = net_wm_icon_name;
+
+    if (p->properties[ PROTOCOLS ] & WMVisibleIconName)
+	atoms[pnum++] = net_wm_visible_icon_name;
+
+    if (p->properties[ PROTOCOLS ] & WMDesktop)
+	atoms[pnum++] = net_wm_desktop;
+
+    if (p->properties[ PROTOCOLS ] & WMWindowType) {
+	atoms[pnum++] = net_wm_window_type;
+
+	// Application window types
+        if (p->properties[ WINDOW_TYPES ] & NormalMask)
+	    atoms[pnum++] = net_wm_window_type_normal;
+        if (p->properties[ WINDOW_TYPES ] & DesktopMask)
+	    atoms[pnum++] = net_wm_window_type_desktop;
+        if (p->properties[ WINDOW_TYPES ] & DockMask)
+            atoms[pnum++] = net_wm_window_type_dock;
+        if (p->properties[ WINDOW_TYPES ] & ToolbarMask)
+	    atoms[pnum++] = net_wm_window_type_toolbar;
+        if (p->properties[ WINDOW_TYPES ] & MenuMask)
+	    atoms[pnum++] = net_wm_window_type_menu;
+        if (p->properties[ WINDOW_TYPES ] & DialogMask)
+	    atoms[pnum++] = net_wm_window_type_dialog;
+        if (p->properties[ WINDOW_TYPES ] & UtilityMask)
+	    atoms[pnum++] = net_wm_window_type_utility;
+        if (p->properties[ WINDOW_TYPES ] & SplashMask)
+	    atoms[pnum++] = net_wm_window_type_splash;
+        if (p->properties[ WINDOW_TYPES ] & DropdownMenuMask)
+	    atoms[pnum++] = net_wm_window_type_dropdown_menu;
+        if (p->properties[ WINDOW_TYPES ] & PopupMenuMask)
+	    atoms[pnum++] = net_wm_window_type_popup_menu;
+        if (p->properties[ WINDOW_TYPES ] & TooltipMask)
+	    atoms[pnum++] = net_wm_window_type_tooltip;
+        if (p->properties[ WINDOW_TYPES ] & NotificationMask)
+	    atoms[pnum++] = net_wm_window_type_notification;
+        if (p->properties[ WINDOW_TYPES ] & ComboBoxMask)
+	    atoms[pnum++] = net_wm_window_type_combobox;
+        if (p->properties[ WINDOW_TYPES ] & DNDIconMask)
+	    atoms[pnum++] = net_wm_window_type_dnd;
+	// KDE extensions
+        if (p->properties[ WINDOW_TYPES ] & OverrideMask)
+	    atoms[pnum++] = kde_net_wm_window_type_override;
+        if (p->properties[ WINDOW_TYPES ] & TopMenuMask)
+	    atoms[pnum++] = kde_net_wm_window_type_topmenu;
+    }
+
+    if (p->properties[ PROTOCOLS ] & WMState) {
+	atoms[pnum++] = net_wm_state;
+
+	// Application window states
+        if (p->properties[ STATES ] & Modal)
+    	    atoms[pnum++] = net_wm_state_modal;
+        if (p->properties[ STATES ] & Sticky)
+	    atoms[pnum++] = net_wm_state_sticky;
+        if (p->properties[ STATES ] & MaxVert)
+	    atoms[pnum++] = net_wm_state_max_vert;
+        if (p->properties[ STATES ] & MaxHoriz)
+	    atoms[pnum++] = net_wm_state_max_horiz;
+        if (p->properties[ STATES ] & Shaded)
+	    atoms[pnum++] = net_wm_state_shaded;
+        if (p->properties[ STATES ] & SkipTaskbar)
+	    atoms[pnum++] = net_wm_state_skip_taskbar;
+        if (p->properties[ STATES ] & SkipPager)
+	    atoms[pnum++] = net_wm_state_skip_pager;
+        if (p->properties[ STATES ] & Hidden)
+	    atoms[pnum++] = net_wm_state_hidden;
+        if (p->properties[ STATES ] & FullScreen)
+	    atoms[pnum++] = net_wm_state_fullscreen;
+        if (p->properties[ STATES ] & KeepAbove)
+	    atoms[pnum++] = net_wm_state_above;
+        if (p->properties[ STATES ] & KeepBelow)
+	    atoms[pnum++] = net_wm_state_below;
+        if (p->properties[ STATES ] & DemandsAttention)
+	    atoms[pnum++] = net_wm_state_demands_attention;
+
+        if (p->properties[ STATES ] & StaysOnTop)
+	    atoms[pnum++] = net_wm_state_stays_on_top;
+    }
+
+    if (p->properties[ PROTOCOLS ] & WMStrut)
+	atoms[pnum++] = net_wm_strut;
+
+    if (p->properties[ PROTOCOLS2 ] & WM2ExtendedStrut)
+	atoms[pnum++] = net_wm_extended_strut;
+
+    if (p->properties[ PROTOCOLS ] & WMIconGeometry)
+	atoms[pnum++] = net_wm_icon_geometry;
+
+    if (p->properties[ PROTOCOLS ] & WMIcon)
+	atoms[pnum++] = net_wm_icon;
+
+    if (p->properties[ PROTOCOLS ] & WMPid)
+	atoms[pnum++] = net_wm_pid;
+
+    if (p->properties[ PROTOCOLS ] & WMHandledIcons)
+	atoms[pnum++] = net_wm_handled_icons;
+
+    if (p->properties[ PROTOCOLS ] & WMPing)
+	atoms[pnum++] = net_wm_ping;
+
+    if (p->properties[ PROTOCOLS2 ] & WM2TakeActivity)
+	atoms[pnum++] = net_wm_take_activity;
+
+    if (p->properties[ PROTOCOLS2 ] & WM2UserTime)
+	atoms[pnum++] = net_wm_user_time;
+
+    if (p->properties[ PROTOCOLS2 ] & WM2StartupId)
+	atoms[pnum++] = net_startup_id;
+
+    if (p->properties[ PROTOCOLS2 ] & WM2AllowedActions) {
+        atoms[pnum++] = net_wm_allowed_actions;
+
+	// Actions
+        if (p->properties[ ACTIONS ] & ActionMove)
+    	    atoms[pnum++] = net_wm_action_move;
+        if (p->properties[ ACTIONS ] & ActionResize)
+    	    atoms[pnum++] = net_wm_action_resize;
+        if (p->properties[ ACTIONS ] & ActionMinimize)
+    	    atoms[pnum++] = net_wm_action_minimize;
+        if (p->properties[ ACTIONS ] & ActionShade)
+    	    atoms[pnum++] = net_wm_action_shade;
+        if (p->properties[ ACTIONS ] & ActionStick)
+    	    atoms[pnum++] = net_wm_action_stick;
+        if (p->properties[ ACTIONS ] & ActionMaxVert)
+    	    atoms[pnum++] = net_wm_action_max_vert;
+        if (p->properties[ ACTIONS ] & ActionMaxHoriz)
+    	    atoms[pnum++] = net_wm_action_max_horiz;
+        if (p->properties[ ACTIONS ] & ActionFullScreen)
+    	    atoms[pnum++] = net_wm_action_fullscreen;
+        if (p->properties[ ACTIONS ] & ActionChangeDesktop)
+    	    atoms[pnum++] = net_wm_action_change_desk;
+        if (p->properties[ ACTIONS ] & ActionClose)
+    	    atoms[pnum++] = net_wm_action_close;
+    }
+
+    // KDE specific extensions
+    if (p->properties[ PROTOCOLS ] & KDESystemTrayWindows)
+	atoms[pnum++] = kde_net_system_tray_windows;
+
+    if (p->properties[ PROTOCOLS ] & WMKDESystemTrayWinFor)
+	atoms[pnum++] = kde_net_wm_system_tray_window_for;
+
+    if (p->properties[ PROTOCOLS ] & WMFrameExtents) {
+	atoms[pnum++] = net_frame_extents;
+	atoms[pnum++] = kde_net_wm_frame_strut;
+    }
+
+    if (p->properties[ PROTOCOLS2 ] & WM2KDETemporaryRules)
+	atoms[pnum++] = kde_net_wm_temporary_rules;
+    if (p->properties[ PROTOCOLS2 ] & WM2FullPlacement)
+	atoms[pnum++] = net_wm_full_placement;
+
+    XChangeProperty(p->display, p->root, net_supported, XA_ATOM, 32,
+		    PropModeReplace, (unsigned char *) atoms, pnum);
+    XChangeProperty(p->display, p->root, net_supporting_wm_check, XA_WINDOW, 32,
+	 	    PropModeReplace, (unsigned char *) &(p->supportwindow), 1);
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr,
+	    "NETRootInfo::setSupported: _NET_SUPPORTING_WM_CHECK = 0x%lx on 0x%lx\n"
+	    "                         : _NET_WM_NAME = '%s' on 0x%lx\n",
+	    p->supportwindow, p->supportwindow, p->name, p->supportwindow);
+#endif
+
+    XChangeProperty(p->display, p->supportwindow, net_supporting_wm_check,
+		    XA_WINDOW, 32, PropModeReplace,
+		    (unsigned char *) &(p->supportwindow), 1);
+    XChangeProperty(p->display, p->supportwindow, net_wm_name, UTF8_STRING, 8,
+		    PropModeReplace, (unsigned char *) p->name,
+		    strlen(p->name));
+}
+
+void NETRootInfo::updateSupportedProperties( Atom atom )
+{
+    if( atom == net_supported )
+        p->properties[ PROTOCOLS ] |= Supported;
+
+    else if( atom == net_supporting_wm_check )
+        p->properties[ PROTOCOLS ] |= SupportingWMCheck;
+
+    else if( atom == net_client_list )
+        p->properties[ PROTOCOLS ] |= ClientList;
+
+    else if( atom == net_client_list_stacking )
+        p->properties[ PROTOCOLS ] |= ClientListStacking;
+
+    else if( atom == net_number_of_desktops )
+        p->properties[ PROTOCOLS ] |= NumberOfDesktops;
+
+    else if( atom == net_desktop_geometry )
+        p->properties[ PROTOCOLS ] |= DesktopGeometry;
+
+    else if( atom == net_desktop_viewport )
+        p->properties[ PROTOCOLS ] |= DesktopViewport;
+
+    else if( atom == net_current_desktop )
+        p->properties[ PROTOCOLS ] |= CurrentDesktop;
+
+    else if( atom == net_desktop_names )
+        p->properties[ PROTOCOLS ] |= DesktopNames;
+
+    else if( atom == net_active_window )
+        p->properties[ PROTOCOLS ] |= ActiveWindow;
+
+    else if( atom == net_workarea )
+        p->properties[ PROTOCOLS ] |= WorkArea;
+
+    else if( atom == net_virtual_roots )
+        p->properties[ PROTOCOLS ] |= VirtualRoots;
+
+    else if( atom == net_desktop_layout )
+        p->properties[ PROTOCOLS2 ] |= WM2DesktopLayout;
+
+    else if( atom == net_close_window )
+        p->properties[ PROTOCOLS ] |= CloseWindow;
+
+    else if( atom == net_restack_window )
+        p->properties[ PROTOCOLS2 ] |= WM2RestackWindow;
+
+    else if( atom == net_showing_desktop )
+        p->properties[ PROTOCOLS2 ] |= WM2ShowingDesktop;
+
+    // Application window properties/messages
+    else if( atom == net_wm_moveresize )
+        p->properties[ PROTOCOLS ] |= WMMoveResize;
+
+    else if( atom == net_moveresize_window )
+        p->properties[ PROTOCOLS2 ] |= WM2MoveResizeWindow;
+
+    else if( atom == net_wm_name )
+        p->properties[ PROTOCOLS ] |= WMName;
+
+    else if( atom == net_wm_visible_name )
+        p->properties[ PROTOCOLS ] |= WMVisibleName;
+
+    else if( atom == net_wm_icon_name )
+        p->properties[ PROTOCOLS ] |= WMIconName;
+
+    else if( atom == net_wm_visible_icon_name )
+        p->properties[ PROTOCOLS ] |= WMVisibleIconName;
+
+    else if( atom == net_wm_desktop )
+        p->properties[ PROTOCOLS ] |= WMDesktop;
+
+    else if( atom == net_wm_window_type )
+        p->properties[ PROTOCOLS ] |= WMWindowType;
+
+	// Application window types
+    else if( atom == net_wm_window_type_normal )
+        p->properties[ WINDOW_TYPES ] |= NormalMask;
+    else if( atom == net_wm_window_type_desktop )
+        p->properties[ WINDOW_TYPES ] |= DesktopMask;
+    else if( atom == net_wm_window_type_dock )
+        p->properties[ WINDOW_TYPES ] |= DockMask;
+    else if( atom == net_wm_window_type_toolbar )
+        p->properties[ WINDOW_TYPES ] |= ToolbarMask;
+    else if( atom == net_wm_window_type_menu )
+        p->properties[ WINDOW_TYPES ] |= MenuMask;
+    else if( atom == net_wm_window_type_dialog )
+        p->properties[ WINDOW_TYPES ] |= DialogMask;
+    else if( atom == net_wm_window_type_utility )
+        p->properties[ WINDOW_TYPES ] |= UtilityMask;
+    else if( atom == net_wm_window_type_splash )
+        p->properties[ WINDOW_TYPES ] |= SplashMask;
+    else if( atom == net_wm_window_type_dropdown_menu )
+        p->properties[ WINDOW_TYPES ] |= DropdownMenuMask;
+    else if( atom == net_wm_window_type_popup_menu )
+        p->properties[ WINDOW_TYPES ] |= PopupMenuMask;
+    else if( atom == net_wm_window_type_tooltip )
+        p->properties[ WINDOW_TYPES ] |= TooltipMask;
+    else if( atom == net_wm_window_type_notification )
+        p->properties[ WINDOW_TYPES ] |= NotificationMask;
+    else if( atom == net_wm_window_type_combobox )
+        p->properties[ WINDOW_TYPES ] |= ComboBoxMask;
+    else if( atom == net_wm_window_type_dnd )
+        p->properties[ WINDOW_TYPES ] |= DNDIconMask;
+	// KDE extensions
+    else if( atom == kde_net_wm_window_type_override )
+        p->properties[ WINDOW_TYPES ] |= OverrideMask;
+    else if( atom == kde_net_wm_window_type_topmenu )
+        p->properties[ WINDOW_TYPES ] |= TopMenuMask;
+
+    else if( atom == net_wm_state )
+        p->properties[ PROTOCOLS ] |= WMState;
+
+	// Application window states
+    else if( atom == net_wm_state_modal )
+        p->properties[ STATES ] |= Modal;
+    else if( atom == net_wm_state_sticky )
+        p->properties[ STATES ] |= Sticky;
+    else if( atom == net_wm_state_max_vert )
+        p->properties[ STATES ] |= MaxVert;
+    else if( atom == net_wm_state_max_horiz )
+        p->properties[ STATES ] |= MaxHoriz;
+    else if( atom == net_wm_state_shaded )
+        p->properties[ STATES ] |= Shaded;
+    else if( atom == net_wm_state_skip_taskbar )
+        p->properties[ STATES ] |= SkipTaskbar;
+    else if( atom == net_wm_state_skip_pager )
+        p->properties[ STATES ] |= SkipPager;
+    else if( atom == net_wm_state_hidden )
+        p->properties[ STATES ] |= Hidden;
+    else if( atom == net_wm_state_fullscreen )
+        p->properties[ STATES ] |= FullScreen;
+    else if( atom == net_wm_state_above )
+        p->properties[ STATES ] |= KeepAbove;
+    else if( atom == net_wm_state_below )
+        p->properties[ STATES ] |= KeepBelow;
+    else if( atom == net_wm_state_demands_attention )
+        p->properties[ STATES ] |= DemandsAttention;
+
+    else if( atom == net_wm_state_stays_on_top )
+        p->properties[ STATES ] |= StaysOnTop;
+
+    else if( atom == net_wm_strut )
+        p->properties[ PROTOCOLS ] |= WMStrut;
+
+    else if( atom == net_wm_extended_strut )
+        p->properties[ PROTOCOLS2 ] |= WM2ExtendedStrut;
+
+    else if( atom == net_wm_icon_geometry )
+        p->properties[ PROTOCOLS ] |= WMIconGeometry;
+
+    else if( atom == net_wm_icon )
+        p->properties[ PROTOCOLS ] |= WMIcon;
+
+    else if( atom == net_wm_pid )
+        p->properties[ PROTOCOLS ] |= WMPid;
+
+    else if( atom == net_wm_handled_icons )
+        p->properties[ PROTOCOLS ] |= WMHandledIcons;
+
+    else if( atom == net_wm_ping )
+        p->properties[ PROTOCOLS ] |= WMPing;
+
+    else if( atom == net_wm_take_activity )
+        p->properties[ PROTOCOLS2 ] |= WM2TakeActivity;
+
+    else if( atom == net_wm_user_time )
+        p->properties[ PROTOCOLS2 ] |= WM2UserTime;
+
+    else if( atom == net_startup_id )
+        p->properties[ PROTOCOLS2 ] |= WM2StartupId;
+
+    else if( atom == net_wm_allowed_actions )
+        p->properties[ PROTOCOLS2 ] |= WM2AllowedActions;
+
+        // Actions
+    else if( atom == net_wm_action_move )
+        p->properties[ ACTIONS ] |= ActionMove;
+    else if( atom == net_wm_action_resize )
+        p->properties[ ACTIONS ] |= ActionResize;
+    else if( atom == net_wm_action_minimize )
+        p->properties[ ACTIONS ] |= ActionMinimize;
+    else if( atom == net_wm_action_shade )
+        p->properties[ ACTIONS ] |= ActionShade;
+    else if( atom == net_wm_action_stick )
+        p->properties[ ACTIONS ] |= ActionStick;
+    else if( atom == net_wm_action_max_vert )
+        p->properties[ ACTIONS ] |= ActionMaxVert;
+    else if( atom == net_wm_action_max_horiz )
+        p->properties[ ACTIONS ] |= ActionMaxHoriz;
+    else if( atom == net_wm_action_fullscreen )
+        p->properties[ ACTIONS ] |= ActionFullScreen;
+    else if( atom == net_wm_action_change_desk )
+        p->properties[ ACTIONS ] |= ActionChangeDesktop;
+    else if( atom == net_wm_action_close )
+        p->properties[ ACTIONS ] |= ActionClose;
+
+    // KDE specific extensions
+    else if( atom == kde_net_system_tray_windows )
+        p->properties[ PROTOCOLS ] |= KDESystemTrayWindows;
+
+    else if( atom == kde_net_wm_system_tray_window_for )
+        p->properties[ PROTOCOLS ] |= WMKDESystemTrayWinFor;
+
+    else if( atom == net_frame_extents )
+        p->properties[ PROTOCOLS ] |= WMFrameExtents;
+    else if( atom == kde_net_wm_frame_strut )
+        p->properties[ PROTOCOLS ] |= WMKDEFrameStrut;
+
+    else if( atom == kde_net_wm_temporary_rules )
+        p->properties[ PROTOCOLS2 ] |= WM2KDETemporaryRules;
+    else if( atom == net_wm_full_placement )
+        p->properties[ PROTOCOLS2 ] |= WM2FullPlacement;
+}
+
+void NETRootInfo::setActiveWindow(Window window) {
+    setActiveWindow( window, FromUnknown, GET_QT_X_USER_TIME(), None );
+}
+
+void NETRootInfo::setActiveWindow(Window window, NET::RequestSource src,
+    Time timestamp, Window active_window ) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::setActiveWindow(0x%lx) (%s)\n",
+            window, (role == WindowManager) ? "WM" : "Client");
+#endif
+
+    if (role == WindowManager) {
+	p->active = window;
+	XChangeProperty(p->display, p->root, net_active_window, XA_WINDOW, 32,
+			PropModeReplace, (unsigned char *) &(p->active), 1);
+    } else {
+	XEvent e;
+
+	e.xclient.type = ClientMessage;
+	e.xclient.message_type = net_active_window;
+	e.xclient.display = p->display;
+	e.xclient.window = window;
+	e.xclient.format = 32;
+	e.xclient.data.l[0] = src;
+	e.xclient.data.l[1] = timestamp;
+	e.xclient.data.l[2] = active_window;
+	e.xclient.data.l[3] = 0l;
+	e.xclient.data.l[4] = 0l;
+
+	XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+    }
+}
+
+
+void NETRootInfo::setWorkArea(int desktop, const NETRect &workarea) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::setWorkArea(%d, { %d, %d, %d, %d }) (%s)\n",
+	    desktop, workarea.pos.x, workarea.pos.y, workarea.size.width, workarea.size.height,
+	    (role == WindowManager) ? "WM" : "Client");
+#endif
+
+    if (role != WindowManager || desktop < 1) return;
+
+    p->workarea[desktop - 1] = workarea;
+
+    long *wa = new long[p->number_of_desktops * 4];
+    int i, o;
+    for (i = 0, o = 0; i < p->number_of_desktops; i++) {
+	wa[o++] = p->workarea[i].pos.x;
+	wa[o++] = p->workarea[i].pos.y;
+	wa[o++] = p->workarea[i].size.width;
+	wa[o++] = p->workarea[i].size.height;
+    }
+
+    XChangeProperty(p->display, p->root, net_workarea, XA_CARDINAL, 32,
+		    PropModeReplace, (unsigned char *) wa,
+		    p->number_of_desktops * 4);
+
+    delete [] wa;
+}
+
+
+void NETRootInfo::setVirtualRoots(Window *windows, unsigned int count) {
+    if (role != WindowManager) return;
+
+    p->virtual_roots_count = count;
+    p->virtual_roots = windows;
+
+#ifdef   NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::setVirtualRoots: setting list with %ld windows\n",
+	    p->virtual_roots_count);
+#endif
+
+    XChangeProperty(p->display, p->root, net_virtual_roots, XA_WINDOW, 32,
+		    PropModeReplace, (unsigned char *) p->virtual_roots,
+		    p->virtual_roots_count);
+}
+
+
+void NETRootInfo::setDesktopLayout(NET::Orientation orientation, int columns, int rows,
+    NET::DesktopLayoutCorner corner)
+{
+    p->desktop_layout_orientation = orientation;
+    p->desktop_layout_columns = columns;
+    p->desktop_layout_rows = rows;
+    p->desktop_layout_corner = corner;
+
+#ifdef   NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::setDesktopLayout: %d %d %d %d\n",
+	    orientation, columns, rows, corner);
+#endif
+
+    long data[ 4 ];
+    data[ 0 ] = orientation;
+    data[ 1 ] = columns;
+    data[ 2 ] = rows;
+    data[ 3 ] = corner;
+    XChangeProperty(p->display, p->root, net_desktop_layout, XA_CARDINAL, 32,
+		    PropModeReplace, (unsigned char *) &data, 4);
+}
+
+
+void NETRootInfo::setShowingDesktop( bool showing ) {
+    if (role == WindowManager) {
+	long d = p->showing_desktop = showing;
+	XChangeProperty(p->display, p->root, net_showing_desktop, XA_CARDINAL, 32,
+			PropModeReplace, (unsigned char *) &d, 1);
+    } else {
+	XEvent e;
+
+	e.xclient.type = ClientMessage;
+	e.xclient.message_type = net_showing_desktop;
+	e.xclient.display = p->display;
+	e.xclient.window = 0;
+	e.xclient.format = 32;
+	e.xclient.data.l[0] = showing ? 1 : 0;
+	e.xclient.data.l[1] = 0;
+	e.xclient.data.l[2] = 0;
+	e.xclient.data.l[3] = 0;
+	e.xclient.data.l[4] = 0;
+
+	XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+    }
+}
+
+
+bool NETRootInfo::showingDesktop() const {
+    return p->showing_desktop;
+}
+
+
+void NETRootInfo::closeWindowRequest(Window window) {
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::closeWindowRequest: requesting close for 0x%lx\n",
+	    window);
+#endif
+
+    XEvent e;
+
+    e.xclient.type = ClientMessage;
+    e.xclient.message_type = net_close_window;
+    e.xclient.display = p->display;
+    e.xclient.window = window;
+    e.xclient.format = 32;
+    e.xclient.data.l[0] = 0l;
+    e.xclient.data.l[1] = 0l;
+    e.xclient.data.l[2] = 0l;
+    e.xclient.data.l[3] = 0l;
+    e.xclient.data.l[4] = 0l;
+
+    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+}
+
+
+void NETRootInfo::moveResizeRequest(Window window, int x_root, int y_root,
+				    Direction direction)
+{
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr,
+	    "NETRootInfo::moveResizeRequest: requesting resize/move for 0x%lx (%d, %d, %d)\n",
+	    window, x_root, y_root, direction);
+#endif
+
+    XEvent e;
+
+    e.xclient.type = ClientMessage;
+    e.xclient.message_type = net_wm_moveresize;
+    e.xclient.display = p->display;
+    e.xclient.window = window,
+    e.xclient.format = 32;
+    e.xclient.data.l[0] = x_root;
+    e.xclient.data.l[1] = y_root;
+    e.xclient.data.l[2] = direction;
+    e.xclient.data.l[3] = 0l;
+    e.xclient.data.l[4] = 0l;
+
+    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+}
+
+void NETRootInfo::moveResizeWindowRequest(Window window, int flags, int x, int y, int width, int height )
+{
+
+#ifdef    NETWMDEBUG
+    fprintf(stderr,
+	    "NETRootInfo::moveResizeWindowRequest: resizing/moving 0x%lx (%d, %d, %d, %d, %d)\n",
+	    window, flags, x, y, width, height);
+#endif
+
+    XEvent e;
+
+    e.xclient.type = ClientMessage;
+    e.xclient.message_type = net_moveresize_window;
+    e.xclient.display = p->display;
+    e.xclient.window = window,
+    e.xclient.format = 32;
+    e.xclient.data.l[0] = flags;
+    e.xclient.data.l[1] = x;
+    e.xclient.data.l[2] = y;
+    e.xclient.data.l[3] = width;
+    e.xclient.data.l[4] = height;
+
+    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+}
+
+void NETRootInfo::restackRequest(Window window, Window above, int detail)
+{
+    restackRequest( window, FromTool, above, detail, GET_QT_X_USER_TIME() );
+}
+
+void NETRootInfo::restackRequest(Window window, RequestSource src, Window above, int detail, Time timestamp )
+{
+#ifdef    NETWMDEBUG
+    fprintf(stderr,
+	    "NETRootInfo::restackRequest: requesting restack for 0x%lx (%lx, %d)\n",
+	    window, above, detail);
+#endif
+
+    XEvent e;
+
+    e.xclient.type = ClientMessage;
+    e.xclient.message_type = net_restack_window;
+    e.xclient.display = p->display;
+    e.xclient.window = window,
+    e.xclient.format = 32;
+    e.xclient.data.l[0] = src;
+    e.xclient.data.l[1] = above;
+    e.xclient.data.l[2] = detail;
+    e.xclient.data.l[3] = timestamp;
+    e.xclient.data.l[4] = 0l;
+
+    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+}
+
+void NETRootInfo2::sendPing( Window window, Time timestamp )
+{
+    if (role != WindowManager) return;
+#ifdef   NETWMDEBUG
+    fprintf(stderr, "NETRootInfo2::setPing: window 0x%lx, timestamp %lu\n",
+	window, timestamp );
+#endif
+    XEvent e;
+    e.xclient.type = ClientMessage;
+    e.xclient.message_type = wm_protocols;
+    e.xclient.display = p->display;
+    e.xclient.window = window,
+    e.xclient.format = 32;
+    e.xclient.data.l[0] = net_wm_ping;
+    e.xclient.data.l[1] = timestamp;
+    e.xclient.data.l[2] = window;
+    e.xclient.data.l[3] = 0;
+    e.xclient.data.l[4] = 0;
+
+    XSendEvent(p->display, window, False, 0, &e);
+}
+
+void NETRootInfo3::takeActivity( Window window, Time timestamp, long flags )
+{
+    if (role != WindowManager) return;
+#ifdef   NETWMDEBUG
+    fprintf(stderr, "NETRootInfo2::takeActivity: window 0x%lx, timestamp %lu, flags 0x%lx\n",
+	window, timestamp, flags );
+#endif
+    XEvent e;
+    e.xclient.type = ClientMessage;
+    e.xclient.message_type = wm_protocols;
+    e.xclient.display = p->display;
+    e.xclient.window = window,
+    e.xclient.format = 32;
+    e.xclient.data.l[0] = net_wm_take_activity;
+    e.xclient.data.l[1] = timestamp;
+    e.xclient.data.l[2] = window;
+    e.xclient.data.l[3] = flags;
+    e.xclient.data.l[4] = 0;
+
+    XSendEvent(p->display, window, False, 0, &e);
+}
+
+
+
+// assignment operator
+
+const NETRootInfo &NETRootInfo::operator=(const NETRootInfo &rootinfo) {
+
+#ifdef   NETWMDEBUG
+    fprintf(stderr, "NETRootInfo::operator=()\n");
+#endif
+
+    if (p != rootinfo.p) {
+	refdec_nri(p);
+
+	if (! p->ref) delete p;
+    }
+
+    p = rootinfo.p;
+    role = rootinfo.role;
+    p->ref++;
+
+    return *this;
+}
+
+unsigned long NETRootInfo::event(XEvent *ev )
+{
+    unsigned long props[ 1 ];
+    event( ev, props, 1 );
+    return props[ 0 ];
+}
+
+void NETRootInfo::event(XEvent *event, unsigned long* properties, int properties_size )
+{
+    unsigned long props[ PROPERTIES_SIZE ] = { 0, 0, 0, 0, 0 };
+    assert( PROPERTIES_SIZE == 5 ); // add elements above
+    unsigned long& dirty = props[ PROTOCOLS ];
+    unsigned long& dirty2 = props[ PROTOCOLS2 ];
+    bool do_update = false;
+
+    // the window manager will be interested in client messages... no other
+    // client should get these messages
+    if (role == WindowManager && event->type == ClientMessage &&
+	event->xclient.format == 32) {
+#ifdef    NETWMDEBUG
+	fprintf(stderr, "NETRootInfo::event: handling ClientMessage event\n");
+#endif
+
+	if (event->xclient.message_type == net_number_of_desktops) {
+	    dirty = NumberOfDesktops;
+
+#ifdef   NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: changeNumberOfDesktops(%ld)\n",
+		    event->xclient.data.l[0]);
+#endif
+
+	    changeNumberOfDesktops(event->xclient.data.l[0]);
+	} else if (event->xclient.message_type == net_desktop_geometry) {
+	    dirty = DesktopGeometry;
+
+	    NETSize sz;
+	    sz.width = event->xclient.data.l[0];
+	    sz.height = event->xclient.data.l[1];
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: changeDesktopGeometry( -- , { %d, %d })\n",
+		    sz.width, sz.height);
+#endif
+
+	    changeDesktopGeometry(~0, sz);
+	} else if (event->xclient.message_type == net_desktop_viewport) {
+	    dirty = DesktopViewport;
+
+	    NETPoint pt;
+	    pt.x = event->xclient.data.l[0];
+	    pt.y = event->xclient.data.l[1];
+
+#ifdef   NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: changeDesktopViewport(%d, { %d, %d })\n",
+		    p->current_desktop, pt.x, pt.y);
+#endif
+
+	    changeDesktopViewport(p->current_desktop, pt);
+	} else if (event->xclient.message_type == net_current_desktop) {
+	    dirty = CurrentDesktop;
+
+#ifdef   NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: changeCurrentDesktop(%ld)\n",
+		    event->xclient.data.l[0] + 1);
+#endif
+
+	    changeCurrentDesktop(event->xclient.data.l[0] + 1);
+	} else if (event->xclient.message_type == net_active_window) {
+	    dirty = ActiveWindow;
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: changeActiveWindow(0x%lx)\n",
+		    event->xclient.window);
+#endif
+
+	    changeActiveWindow(event->xclient.window);
+	    if( NETRootInfo2* this2 = dynamic_cast< NETRootInfo2* >( this ))
+            {
+                RequestSource src = FromUnknown;
+                Time timestamp = CurrentTime;
+                Window active_window = None;
+                // make sure there aren't unknown values
+                if( event->xclient.data.l[0] >= FromUnknown
+                    && event->xclient.data.l[0] <= FromTool )
+                    {
+                    src = static_cast< RequestSource >( event->xclient.data.l[0] );
+                    timestamp = event->xclient.data.l[1];
+                    active_window = event->xclient.data.l[2];
+                    }
+		this2->changeActiveWindow( event->xclient.window, src, timestamp, active_window );
+            }
+	} else if (event->xclient.message_type == net_wm_moveresize) {
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: moveResize(%ld, %ld, %ld, %ld)\n",
+		    event->xclient.window,
+		    event->xclient.data.l[0],
+		    event->xclient.data.l[1],
+		    event->xclient.data.l[2]
+		    );
+#endif
+
+	    moveResize(event->xclient.window,
+		       event->xclient.data.l[0],
+		       event->xclient.data.l[1],
+		       event->xclient.data.l[2]);
+	} else if (event->xclient.message_type == net_moveresize_window) {
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: moveResizeWindow(%ld, %ld, %ld, %ld, %ld, %ld)\n",
+		    event->xclient.window,
+		    event->xclient.data.l[0],
+		    event->xclient.data.l[1],
+		    event->xclient.data.l[2],
+		    event->xclient.data.l[3],
+		    event->xclient.data.l[4]
+		    );
+#endif
+
+	    if( NETRootInfo2* this2 = dynamic_cast< NETRootInfo2* >( this ))
+	        this2->moveResizeWindow(event->xclient.window,
+		           event->xclient.data.l[0],
+		           event->xclient.data.l[1],
+		           event->xclient.data.l[2],
+		           event->xclient.data.l[3],
+		           event->xclient.data.l[4]);
+	} else if (event->xclient.message_type == net_close_window) {
+
+#ifdef   NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: closeWindow(0x%lx)\n",
+		    event->xclient.window);
+#endif
+
+	    closeWindow(event->xclient.window);
+	} else if (event->xclient.message_type == net_restack_window) {
+
+#ifdef   NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: restackWindow(0x%lx)\n",
+		    event->xclient.window);
+#endif
+
+	    if( NETRootInfo3* this3 = dynamic_cast< NETRootInfo3* >( this ))
+            {
+                RequestSource src = FromUnknown;
+                Time timestamp = CurrentTime;
+                // make sure there aren't unknown values
+                if( event->xclient.data.l[0] >= FromUnknown
+                    && event->xclient.data.l[0] <= FromTool )
+                    {
+                    src = static_cast< RequestSource >( event->xclient.data.l[0] );
+                    timestamp = event->xclient.data.l[3];
+                    }
+	        this3->restackWindow(event->xclient.window, src,
+                    event->xclient.data.l[1], event->xclient.data.l[2], timestamp);
+            }
+	    else if( NETRootInfo2* this2 = dynamic_cast< NETRootInfo2* >( this ))
+	        this2->restackWindow(event->xclient.window,
+                    event->xclient.data.l[1], event->xclient.data.l[2]);
+	} else if (event->xclient.message_type == wm_protocols
+	    && (Atom)event->xclient.data.l[ 0 ] == net_wm_ping) {
+	    dirty = WMPing;
+
+#ifdef   NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo2::event: gotPing(0x%lx,%lu)\n",
+		event->xclient.window, event->xclient.data.l[1]);
+#endif
+	    if( NETRootInfo2* this2 = dynamic_cast< NETRootInfo2* >( this ))
+		this2->gotPing( event->xclient.data.l[2], event->xclient.data.l[1]);
+	} else if (event->xclient.message_type == wm_protocols
+	    && (Atom)event->xclient.data.l[ 0 ] == net_wm_take_activity) {
+	    dirty2 = WM2TakeActivity;
+
+#ifdef   NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo2::event: gotTakeActivity(0x%lx,%lu,0x%lx)\n",
+		event->xclient.window, event->xclient.data.l[1], event->xclient.data.l[3]);
+#endif
+	    if( NETRootInfo3* this3 = dynamic_cast< NETRootInfo3* >( this ))
+		this3->gotTakeActivity( event->xclient.data.l[2], event->xclient.data.l[1],
+                    event->xclient.data.l[3]);
+	} else if (event->xclient.message_type == net_showing_desktop) {
+	    dirty2 = WM2ShowingDesktop;
+
+#ifdef   NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: changeShowingDesktop(%ld)\n",
+		    event->xclient.data.l[0]);
+#endif
+
+	    if( NETRootInfo4* this4 = dynamic_cast< NETRootInfo4* >( this ))
+	        this4->changeShowingDesktop(event->xclient.data.l[0]);
+	}
+    }
+
+    if (event->type == PropertyNotify) {
+
+#ifdef    NETWMDEBUG
+	fprintf(stderr, "NETRootInfo::event: handling PropertyNotify event\n");
+#endif
+
+	XEvent pe = *event;
+
+	Bool done = False;
+	Bool compaction = False;
+	while (! done) {
+
+#ifdef   NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::event: loop fire\n");
+#endif
+
+	    if (pe.xproperty.atom == net_client_list)
+		dirty |= ClientList;
+	    else if (pe.xproperty.atom == net_client_list_stacking)
+		dirty |= ClientListStacking;
+	    else if (pe.xproperty.atom == kde_net_system_tray_windows)
+		dirty |= KDESystemTrayWindows;
+	    else if (pe.xproperty.atom == net_desktop_names)
+		dirty |= DesktopNames;
+	    else if (pe.xproperty.atom == net_workarea)
+		dirty |= WorkArea;
+	    else if (pe.xproperty.atom == net_number_of_desktops)
+		dirty |= NumberOfDesktops;
+	    else if (pe.xproperty.atom == net_desktop_geometry)
+		dirty |= DesktopGeometry;
+	    else if (pe.xproperty.atom == net_desktop_viewport)
+		dirty |= DesktopViewport;
+	    else if (pe.xproperty.atom == net_current_desktop)
+		dirty |= CurrentDesktop;
+	    else if (pe.xproperty.atom == net_active_window)
+		dirty |= ActiveWindow;
+	    else if (pe.xproperty.atom == net_showing_desktop)
+		dirty2 |= WM2ShowingDesktop;
+//            else if (pe.xproperty.atom == net_supported )
+//                dirty |= Supported; // update here?
+            else if (pe.xproperty.atom == net_supporting_wm_check )
+                dirty |= SupportingWMCheck;
+            else if (pe.xproperty.atom == net_virtual_roots )
+                dirty |= VirtualRoots;
+            else if (pe.xproperty.atom == net_desktop_layout )
+                dirty2 |= WM2DesktopLayout;
+	    else {
+
+#ifdef    NETWMDEBUG
+		fprintf(stderr, "NETRootInfo::event: putting back event and breaking\n");
+#endif
+
+		if ( compaction )
+		    XPutBackEvent(p->display, &pe);
+		break;
+	    }
+
+	    if (XCheckTypedWindowEvent(p->display, p->root, PropertyNotify, &pe) )
+		compaction = True;
+	    else
+		break;
+	}
+
+	do_update = true;
+    }
+
+    if( do_update )
+        update( props );
+
+#ifdef   NETWMDEBUG
+     fprintf(stderr, "NETRootInfo::event: handled events, returning dirty = 0x%lx, 0x%lx\n",
+ 	    dirty, dirty2);
+#endif
+
+    if( properties_size > PROPERTIES_SIZE )
+        properties_size = PROPERTIES_SIZE;
+    for( int i = 0;
+         i < properties_size;
+         ++i )
+        properties[ i ] = props[ i ];
+}
+
+
+// private functions to update the data we keep
+
+void NETRootInfo::update( const unsigned long dirty_props[] )
+{
+    Atom type_ret;
+    int format_ret;
+    unsigned char *data_ret;
+    unsigned long nitems_ret, unused;
+    unsigned long props[ PROPERTIES_SIZE ];
+    for( int i = 0;
+         i < PROPERTIES_SIZE;
+         ++i )
+        props[ i ] = dirty_props[ i ] & p->client_properties[ i ];
+    const unsigned long& dirty = props[ PROTOCOLS ];
+    const unsigned long& dirty2 = props[ PROTOCOLS2 ];
+
+    if (dirty & Supported ) {
+        // only in Client mode
+        for( int i = 0; i < PROPERTIES_SIZE; ++i )
+            p->properties[ i ] = 0;
+        if( XGetWindowProperty(p->display, p->root, net_supported,
+                               0l, MAX_PROP_SIZE, False, XA_ATOM, &type_ret,
+                               &format_ret, &nitems_ret, &unused, &data_ret)
+            == Success ) {
+            if( type_ret == XA_ATOM && format_ret == 32 ) {
+                Atom* atoms = (Atom*) data_ret;
+                for( unsigned int i = 0;
+                     i < nitems_ret;
+                     ++i )
+                    updateSupportedProperties( atoms[ i ] );
+            }
+	    if ( data_ret )
+		XFree(data_ret);
+        }
+    }
+
+    if (dirty & ClientList) {
+        bool read_ok = false;
+	if (XGetWindowProperty(p->display, p->root, net_client_list,
+			       0l, MAX_PROP_SIZE, False, XA_WINDOW, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_WINDOW && format_ret == 32) {
+		Window *wins = (Window *) data_ret;
+
+		qsort(wins, nitems_ret, sizeof(Window), wcmp);
+
+		if (p->clients) {
+		    if (role == Client) {
+			unsigned long new_index = 0, old_index = 0;
+			unsigned long new_count = nitems_ret,
+				      old_count = p->clients_count;
+
+			while (old_index < old_count || new_index < new_count) {
+			    if (old_index == old_count) {
+				addClient(wins[new_index++]);
+			    } else if (new_index == new_count) {
+				removeClient(p->clients[old_index++]);
+			    } else {
+				if (p->clients[old_index] <
+				    wins[new_index]) {
+				    removeClient(p->clients[old_index++]);
+				} else if (wins[new_index] <
+					   p->clients[old_index]) {
+				    addClient(wins[new_index++]);
+				} else {
+				    new_index++;
+				    old_index++;
+				}
+			    }
+			}
+		    }
+
+		    delete [] p->clients;
+		} else {
+#ifdef    NETWMDEBUG
+		    fprintf(stderr, "NETRootInfo::update: client list null, creating\n");
+#endif
+
+		    unsigned long n;
+		    for (n = 0; n < nitems_ret; n++) {
+			addClient(wins[n]);
+		    }
+		}
+
+		p->clients_count = nitems_ret;
+		p->clients = nwindup(wins, p->clients_count);
+                read_ok = true;
+	    }
+
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+        if( !read_ok ) {
+            for( unsigned int i = 0; i < p->clients_count; ++ i )
+	        removeClient(p->clients[i]);
+            p->clients_count = 0;
+            delete[] p->clients;
+            p->clients = NULL;
+        }
+
+#ifdef    NETWMDEBUG
+	fprintf(stderr, "NETRootInfo::update: client list updated (%ld clients)\n",
+		p->clients_count);
+#endif
+    }
+
+    if (dirty & KDESystemTrayWindows) {
+        bool read_ok = false;
+	if (XGetWindowProperty(p->display, p->root, kde_net_system_tray_windows,
+			       0l, MAX_PROP_SIZE, False, XA_WINDOW, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_WINDOW && format_ret == 32) {
+		Window *wins = (Window *) data_ret;
+
+		qsort(wins, nitems_ret, sizeof(Window), wcmp);
+
+		if (p->kde_system_tray_windows) {
+		    if (role == Client) {
+			unsigned long new_index = 0, new_count = nitems_ret;
+			unsigned long old_index = 0,
+				      old_count = p->kde_system_tray_windows_count;
+
+			while(old_index < old_count || new_index < new_count) {
+			    if (old_index == old_count) {
+				addSystemTrayWin(wins[new_index++]);
+			    } else if (new_index == new_count) {
+				removeSystemTrayWin(p->kde_system_tray_windows[old_index++]);
+			    } else {
+				if (p->kde_system_tray_windows[old_index] <
+				    wins[new_index]) {
+				    removeSystemTrayWin(p->kde_system_tray_windows[old_index++]);
+				} else if (wins[new_index] <
+					   p->kde_system_tray_windows[old_index]) {
+				    addSystemTrayWin(wins[new_index++]);
+				} else {
+				    new_index++;
+				    old_index++;
+				}
+			    }
+			}
+		    }
+
+		} else {
+		    unsigned long n;
+		    for (n = 0; n < nitems_ret; n++) {
+			addSystemTrayWin(wins[n]);
+		    }
+		}
+
+		p->kde_system_tray_windows_count = nitems_ret;
+		delete [] p->kde_system_tray_windows;
+		p->kde_system_tray_windows =
+		    nwindup(wins, p->kde_system_tray_windows_count);
+                read_ok = true;
+	    }
+
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+        if( !read_ok ) {
+            for( unsigned int i = 0; i < p->kde_system_tray_windows_count; ++i )
+                removeSystemTrayWin(p->kde_system_tray_windows[i]);
+            p->kde_system_tray_windows_count = 0;
+	    delete [] p->kde_system_tray_windows;
+            p->kde_system_tray_windows = NULL;
+        }
+    }
+
+    if (dirty & ClientListStacking) {
+        p->stacking_count = 0;
+        delete[] p->stacking;
+        p->stacking = NULL;
+	if (XGetWindowProperty(p->display, p->root, net_client_list_stacking,
+			       0, MAX_PROP_SIZE, False, XA_WINDOW, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_WINDOW && format_ret == 32) {
+		Window *wins = (Window *) data_ret;
+
+		p->stacking_count = nitems_ret;
+		p->stacking = nwindup(wins, p->stacking_count);
+	    }
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr,"NETRootInfo::update: client stacking updated (%ld clients)\n",
+		    p->stacking_count);
+#endif
+
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & NumberOfDesktops) {
+	p->number_of_desktops = 0;
+
+	if (XGetWindowProperty(p->display, p->root, net_number_of_desktops,
+			       0l, 1l, False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 && nitems_ret == 1) {
+		p->number_of_desktops = *((long *) data_ret);
+	    }
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::update: number of desktops = %d\n",
+		    p->number_of_desktops);
+#endif
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & DesktopGeometry) {
+        p->geometry = p->rootSize;
+	if (XGetWindowProperty(p->display, p->root, net_desktop_geometry,
+			       0l, 2l, False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 &&
+		nitems_ret == 2) {
+		long *data = (long *) data_ret;
+
+		p->geometry.width  = data[0];
+		p->geometry.height = data[1];
+
+#ifdef    NETWMDEBUG
+		fprintf(stderr, "NETRootInfo::update: desktop geometry updated\n");
+#endif
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & DesktopViewport) {
+	for (int i = 0; i < p->viewport.size(); i++)
+	    p->viewport[i].x = p->viewport[i].y = 0;
+	if (XGetWindowProperty(p->display, p->root, net_desktop_viewport,
+			       0l, 2l, False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 &&
+		nitems_ret == 2) {
+		long *data = (long *) data_ret;
+
+		int d, i, n;
+		n = nitems_ret / 2;
+		for (d = 0, i = 0; d < n; d++) {
+		    p->viewport[d].x = data[i++];
+		    p->viewport[d].y = data[i++];
+		}
+
+#ifdef    NETWMDEBUG
+		fprintf(stderr,
+			"NETRootInfo::update: desktop viewport array updated (%d entries)\n",
+			p->viewport.size());
+
+		if (nitems_ret % 2 != 0) {
+		    fprintf(stderr,
+			    "NETRootInfo::update(): desktop viewport array "
+			    "size not a multiple of 2\n");
+		}
+#endif
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & CurrentDesktop) {
+	p->current_desktop = 0;
+	if (XGetWindowProperty(p->display, p->root, net_current_desktop,
+			       0l, 1l, False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 && nitems_ret == 1) {
+		p->current_desktop = *((long *) data_ret) + 1;
+	    }
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::update: current desktop = %d\n",
+		    p->current_desktop);
+#endif
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & DesktopNames) {
+        for( int i = 0; i < p->desktop_names.size(); ++i )
+            delete[] p->desktop_names[ i ];
+        p->desktop_names.reset();
+	if (XGetWindowProperty(p->display, p->root, net_desktop_names,
+			       0l, MAX_PROP_SIZE, False, UTF8_STRING, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == UTF8_STRING && format_ret == 8) {
+		const char *d = (const char *) data_ret;
+		unsigned int s, n, index;
+
+		for (s = 0, n = 0, index = 0; n < nitems_ret; n++) {
+		    if (d[n] == '\0') {
+			delete [] p->desktop_names[index];
+			p->desktop_names[index++] = nstrndup((d + s), n - s + 1);
+			s = n + 1;
+		    }
+		}
+	    }
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::update: desktop names array updated (%d entries)\n",
+		    p->desktop_names.size());
+#endif
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & ActiveWindow) {
+        p->active = None;
+	if (XGetWindowProperty(p->display, p->root, net_active_window, 0l, 1l,
+			       False, XA_WINDOW, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_WINDOW && format_ret == 32 && nitems_ret == 1) {
+		p->active = *((Window *) data_ret);
+	    }
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::update: active window = 0x%lx\n",
+		    p->active);
+#endif
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WorkArea) {
+        p->workarea.reset();
+	if (XGetWindowProperty(p->display, p->root, net_workarea, 0l,
+			       (p->number_of_desktops * 4), False, XA_CARDINAL,
+			       &type_ret, &format_ret, &nitems_ret, &unused,
+			       &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 &&
+		nitems_ret == (unsigned) (p->number_of_desktops * 4)) {
+		long *d = (long *) data_ret;
+		int i, j;
+		for (i = 0, j = 0; i < p->number_of_desktops; i++) {
+		    p->workarea[i].pos.x       = d[j++];
+		    p->workarea[i].pos.y       = d[j++];
+		    p->workarea[i].size.width  = d[j++];
+		    p->workarea[i].size.height = d[j++];
+		}
+	    }
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::update: work area array updated (%d entries)\n",
+		    p->workarea.size());
+#endif
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+
+    if (dirty & SupportingWMCheck) {
+        p->supportwindow = None;
+        delete[] p->name;
+        p->name = NULL;
+	if (XGetWindowProperty(p->display, p->root, net_supporting_wm_check,
+			       0l, 1l, False, XA_WINDOW, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_WINDOW && format_ret == 32 && nitems_ret == 1) {
+		p->supportwindow = *((Window *) data_ret);
+
+		unsigned char *name_ret;
+		if (XGetWindowProperty(p->display, p->supportwindow,
+				       net_wm_name, 0l, MAX_PROP_SIZE, False,
+				       UTF8_STRING, &type_ret, &format_ret,
+				       &nitems_ret, &unused, &name_ret)
+		    == Success) {
+		    if (type_ret == UTF8_STRING && format_ret == 8)
+			p->name = nstrndup((const char *) name_ret, nitems_ret);
+
+		    if ( name_ret )
+			XFree(name_ret);
+		}
+	    }
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr,
+		    "NETRootInfo::update: supporting window manager = '%s'\n",
+		    p->name);
+#endif
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & VirtualRoots) {
+        p->virtual_roots_count = 0;
+        delete[] p->virtual_roots;
+        p->virtual_roots = NULL;
+	if (XGetWindowProperty(p->display, p->root, net_virtual_roots,
+			       0, MAX_PROP_SIZE, False, XA_WINDOW, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_WINDOW && format_ret == 32) {
+		Window *wins = (Window *) data_ret;
+
+		p->virtual_roots_count = nitems_ret;
+		p->virtual_roots = nwindup(wins, p->virtual_roots_count);
+	    }
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::updated: virtual roots updated (%ld windows)\n",
+		    p->virtual_roots_count);
+#endif
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty2 & WM2DesktopLayout) {
+        p->desktop_layout_orientation = OrientationHorizontal;
+        p->desktop_layout_corner = DesktopLayoutCornerTopLeft;
+        p->desktop_layout_columns = p->desktop_layout_rows = 0;
+	if (XGetWindowProperty(p->display, p->root, net_desktop_layout,
+			       0, MAX_PROP_SIZE, False, XA_CARDINAL, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32) {
+                long* data = (long*) data_ret;
+                if( nitems_ret >= 4 && data[ 3 ] >= 0 && data[ 3 ] <= 3 )
+                    p->desktop_layout_corner = (NET::DesktopLayoutCorner)data[ 3 ];
+                if( nitems_ret >= 3 ) {
+                    if( data[ 0 ] >= 0 && data[ 0 ] <= 1 )
+                        p->desktop_layout_orientation = (NET::Orientation)data[ 0 ];
+                    p->desktop_layout_columns = data[ 1 ];
+                    p->desktop_layout_rows = data[ 2 ];
+                }
+	    }
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::updated: desktop layout updated (%d %d %d %d)\n",
+                p->desktop_layout_orientation, p->desktop_layout_columns,
+                p->desktop_layout_rows, p->desktop_layout_corner );
+#endif
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty2 & WM2ShowingDesktop) {
+        p->showing_desktop = false;
+	if (XGetWindowProperty(p->display, p->root, net_showing_desktop,
+			       0, MAX_PROP_SIZE, False, XA_CARDINAL, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 && nitems_ret == 1) {
+		p->showing_desktop = *((long *) data_ret);
+	    }
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETRootInfo::update: showing desktop = %d\n",
+		    p->showing_desktop);
+#endif
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+}
+
+
+Display *NETRootInfo::x11Display() const {
+    return p->display;
+}
+
+
+Window NETRootInfo::rootWindow() const {
+    return p->root;
+}
+
+
+Window NETRootInfo::supportWindow() const {
+    return p->supportwindow;
+}
+
+
+const char *NETRootInfo::wmName() const {
+    return p->name; }
+
+
+int NETRootInfo::screenNumber() const {
+    return p->screen;
+}
+
+
+unsigned long NETRootInfo::supported() const {
+    return role == WindowManager
+        ? p->properties[ PROTOCOLS ]
+        : p->client_properties[ PROTOCOLS ];
+}
+
+const unsigned long* NETRootInfo::supportedProperties() const {
+    return p->properties;
+}
+
+const unsigned long* NETRootInfo::passedProperties() const {
+    return role == WindowManager
+        ? p->properties
+        : p->client_properties;
+}
+
+bool NETRootInfo::isSupported( NET::Property property ) const {
+    return p->properties[ PROTOCOLS ] & property;
+}
+
+bool NETRootInfo::isSupported( NET::Property2 property ) const {
+    return p->properties[ PROTOCOLS2 ] & property;
+}
+
+bool NETRootInfo::isSupported( NET::WindowType type ) const {
+    return p->properties[ WINDOW_TYPES ] & type;
+}
+
+bool NETRootInfo::isSupported( NET::State state ) const {
+    return p->properties[ STATES ] & state;
+}
+
+bool NETRootInfo::isSupported( NET::Action action ) const {
+    return p->properties[ ACTIONS ] & action;
+}
+
+const Window *NETRootInfo::clientList() const {
+    return p->clients;
+}
+
+
+int NETRootInfo::clientListCount() const {
+    return p->clients_count;
+}
+
+
+const Window *NETRootInfo::clientListStacking() const {
+    return p->stacking;
+}
+
+
+int NETRootInfo::clientListStackingCount() const {
+    return p->stacking_count;
+}
+
+
+const Window *NETRootInfo::kdeSystemTrayWindows() const {
+    return p->kde_system_tray_windows;
+}
+
+
+int NETRootInfo::kdeSystemTrayWindowsCount() const {
+    return p->kde_system_tray_windows_count;
+}
+
+
+NETSize NETRootInfo::desktopGeometry(int) const {
+    return p->geometry.width != 0 ? p->geometry : p->rootSize;
+}
+
+
+NETPoint NETRootInfo::desktopViewport(int desktop) const {
+    if (desktop < 1) {
+	NETPoint pt; // set to (0,0)
+	return pt;
+    }
+
+    return p->viewport[desktop - 1];
+}
+
+
+NETRect NETRootInfo::workArea(int desktop) const {
+    if (desktop < 1) {
+	NETRect rt;
+	return rt;
+    }
+
+    return p->workarea[desktop - 1];
+}
+
+
+const char *NETRootInfo::desktopName(int desktop) const {
+    if (desktop < 1) {
+	return 0;
+    }
+
+    return p->desktop_names[desktop - 1];
+}
+
+
+const Window *NETRootInfo::virtualRoots( ) const {
+    return p->virtual_roots;
+}
+
+
+int NETRootInfo::virtualRootsCount() const {
+    return p->virtual_roots_count;
+}
+
+
+NET::Orientation NETRootInfo::desktopLayoutOrientation() const {
+    return p->desktop_layout_orientation;
+}
+
+
+TQSize NETRootInfo::desktopLayoutColumnsRows() const {
+    return TQSize( p->desktop_layout_columns, p->desktop_layout_rows );
+}
+
+
+NET::DesktopLayoutCorner NETRootInfo::desktopLayoutCorner() const {
+    return p->desktop_layout_corner;
+}
+
+
+int NETRootInfo::numberOfDesktops() const {
+    return p->number_of_desktops == 0 ? 1 : p->number_of_desktops;
+}
+
+
+int NETRootInfo::currentDesktop() const {
+    return p->current_desktop == 0 ? 1 : p->current_desktop;
+}
+
+
+Window NETRootInfo::activeWindow() const {
+    return p->active;
+}
+
+
+// NETWinInfo stuffs
+
+const int NETWinInfo::OnAllDesktops = NET::OnAllDesktops;
+
+NETWinInfo::NETWinInfo(Display *display, Window window, Window rootWindow,
+		       const unsigned long properties[], int properties_size,
+                       Role role)
+{
+
+#ifdef   NETWMDEBUG
+    fprintf(stderr, "NETWinInfo::NETWinInfo: constructing object with role '%s'\n",
+	    (role == WindowManager) ? "WindowManager" : "Client");
+#endif
+
+    p = new NETWinInfoPrivate;
+    p->ref = 1;
+
+    p->display = display;
+    p->window = window;
+    p->root = rootWindow;
+    p->mapping_state = Withdrawn;
+    p->mapping_state_dirty = True;
+    p->state = 0;
+    p->types[ 0 ] = Unknown;
+    p->name = (char *) 0;
+    p->visible_name = (char *) 0;
+    p->icon_name = (char *) 0;
+    p->visible_icon_name = (char *) 0;
+    p->desktop = p->pid = p->handled_icons = 0;
+    p->user_time = -1U;
+    p->startup_id = NULL;
+    p->transient_for = None;
+    p->window_group = None;
+    p->allowed_actions = 0;
+    p->has_net_support = false;
+    p->class_class = (char*) 0;
+    p->class_name = (char*) 0;
+    p->role = (char*) 0;
+    p->client_machine = (char*) 0;
+
+    // p->strut.left = p->strut.right = p->strut.top = p->strut.bottom = 0;
+    // p->frame_strut.left = p->frame_strut.right = p->frame_strut.top =
+    // p->frame_strut.bottom = 0;
+
+    p->kde_system_tray_win_for = 0;
+
+    for( int i = 0;
+         i < PROPERTIES_SIZE;
+         ++i )
+        p->properties[ i ] = 0;
+    if( properties_size > PROPERTIES_SIZE )
+        properties_size = PROPERTIES_SIZE;
+    for( int i = 0;
+         i < properties_size;
+         ++i )
+        p->properties[ i ] = properties[ i ];
+
+    p->icon_count = 0;
+
+    this->role = role;
+
+    if (! netwm_atoms_created) create_atoms(p->display);
+
+    update(p->properties);
+}
+
+
+NETWinInfo::NETWinInfo(Display *display, Window window, Window rootWindow,
+		       unsigned long properties, Role role)
+{
+
+#ifdef   NETWMDEBUG
+    fprintf(stderr, "NETWinInfo::NETWinInfo: constructing object with role '%s'\n",
+	    (role == WindowManager) ? "WindowManager" : "Client");
+#endif
+
+    p = new NETWinInfoPrivate;
+    p->ref = 1;
+
+    p->display = display;
+    p->window = window;
+    p->root = rootWindow;
+    p->mapping_state = Withdrawn;
+    p->mapping_state_dirty = True;
+    p->state = 0;
+    p->types[ 0 ] = Unknown;
+    p->name = (char *) 0;
+    p->visible_name = (char *) 0;
+    p->icon_name = (char *) 0;
+    p->visible_icon_name = (char *) 0;
+    p->desktop = p->pid = p->handled_icons = 0;
+    p->user_time = -1U;
+    p->startup_id = NULL;
+    p->transient_for = None;
+    p->window_group = None;
+    p->allowed_actions = 0;
+    p->has_net_support = false;
+    p->class_class = (char*) 0;
+    p->class_name = (char*) 0;
+    p->role = (char*) 0;
+    p->client_machine = (char*) 0;
+
+    // p->strut.left = p->strut.right = p->strut.top = p->strut.bottom = 0;
+    // p->frame_strut.left = p->frame_strut.right = p->frame_strut.top =
+    // p->frame_strut.bottom = 0;
+
+    p->kde_system_tray_win_for = 0;
+
+    for( int i = 0;
+         i < PROPERTIES_SIZE;
+         ++i )
+        p->properties[ i ] = 0;
+    p->properties[ PROTOCOLS ] = properties;
+
+    p->icon_count = 0;
+
+    this->role = role;
+
+    if (! netwm_atoms_created) create_atoms(p->display);
+
+    update(p->properties);
+}
+
+
+NETWinInfo::NETWinInfo(const NETWinInfo &wininfo) {
+    p = wininfo.p;
+    p->ref++;
+}
+
+
+NETWinInfo::~NETWinInfo() {
+    refdec_nwi(p);
+
+    if (! p->ref) delete p;
+}
+
+
+// assignment operator
+
+const NETWinInfo &NETWinInfo::operator=(const NETWinInfo &wininfo) {
+
+#ifdef   NETWMDEBUG
+    fprintf(stderr, "NETWinInfo::operator=()\n");
+#endif
+
+    if (p != wininfo.p) {
+	refdec_nwi(p);
+
+	if (! p->ref) delete p;
+    }
+
+    p = wininfo.p;
+    role = wininfo.role;
+    p->ref++;
+
+    return *this;
+}
+
+
+void NETWinInfo::setIcon(NETIcon icon, Bool replace) {
+    setIconInternal( p->icons, p->icon_count, net_wm_icon, icon, replace );
+}
+
+void NETWinInfo::setIconInternal(NETRArray<NETIcon>& icons, int& icon_count, Atom property, NETIcon icon, Bool replace) {
+    if (role != Client) return;
+
+    int proplen, i, sz, j;
+
+    if (replace) {
+
+	for (i = 0; i < icons.size(); i++) {
+	    delete [] icons[i].data;
+	    icons[i].data = 0;
+	    icons[i].size.width = 0;
+	    icons[i].size.height = 0;
+	}
+
+	icon_count = 0;
+    }
+
+    // assign icon
+    icons[icon_count] = icon;
+    icon_count++;
+
+    // do a deep copy, we want to own the data
+    NETIcon &ni = icons[icon_count - 1];
+    sz = ni.size.width * ni.size.height;
+    CARD32 *d = new CARD32[sz];
+    ni.data = (unsigned char *) d;
+    memcpy(d, icon.data, sz * sizeof(CARD32));
+
+    // compute property length
+    for (i = 0, proplen = 0; i < icon_count; i++) {
+	proplen += 2 + (icons[i].size.width *
+			icons[i].size.height);
+    }
+
+    CARD32 *d32;
+    long *prop = new long[proplen], *pprop = prop;
+    for (i = 0; i < icon_count; i++) {
+	// copy size into property
+       	*pprop++ = icons[i].size.width;
+	*pprop++ = icons[i].size.height;
+
+	// copy data into property
+	sz = (icons[i].size.width * icons[i].size.height);
+	d32 = (CARD32 *) icons[i].data;
+	for (j = 0; j < sz; j++) *pprop++ = *d32++;
+    }
+
+    XChangeProperty(p->display, p->window, property, XA_CARDINAL, 32,
+		    PropModeReplace, (unsigned char *) prop, proplen);
+
+    delete [] prop;
+}
+
+
+void NETWinInfo::setIconGeometry(NETRect geometry) {
+    if (role != Client) return;
+
+    p->icon_geom = geometry;
+
+    if( geometry.size.width == 0 ) // empty
+        XDeleteProperty(p->display, p->window, net_wm_icon_geometry);
+    else {
+        long data[4];
+        data[0] = geometry.pos.x;
+        data[1] = geometry.pos.y;
+        data[2] = geometry.size.width;
+        data[3] = geometry.size.height;
+
+        XChangeProperty(p->display, p->window, net_wm_icon_geometry, XA_CARDINAL,
+		    32, PropModeReplace, (unsigned char *) data, 4);
+    }
+}
+
+
+void NETWinInfo::setExtendedStrut(const NETExtendedStrut& extended_strut ) {
+    if (role != Client) return;
+
+    p->extended_strut = extended_strut;
+
+    long data[12];
+    data[0] = extended_strut.left_width;
+    data[1] = extended_strut.right_width;
+    data[2] = extended_strut.top_width;
+    data[3] = extended_strut.bottom_width;
+    data[4] = extended_strut.left_start;
+    data[5] = extended_strut.left_end;
+    data[6] = extended_strut.right_start;
+    data[7] = extended_strut.right_end;
+    data[8] = extended_strut.top_start;
+    data[9] = extended_strut.top_end;
+    data[10] = extended_strut.bottom_start;
+    data[11] = extended_strut.bottom_end;
+
+    XChangeProperty(p->display, p->window, net_wm_extended_strut, XA_CARDINAL, 32,
+		    PropModeReplace, (unsigned char *) data, 12);
+}
+
+
+void NETWinInfo::setStrut(NETStrut strut) {
+    if (role != Client) return;
+
+    p->strut = strut;
+
+    long data[4];
+    data[0] = strut.left;
+    data[1] = strut.right;
+    data[2] = strut.top;
+    data[3] = strut.bottom;
+
+    XChangeProperty(p->display, p->window, net_wm_strut, XA_CARDINAL, 32,
+		    PropModeReplace, (unsigned char *) data, 4);
+}
+
+
+void NETWinInfo::setState(unsigned long state, unsigned long mask) {
+    if (p->mapping_state_dirty)
+	updateWMState();
+
+    // setState() needs to know the current state, so read it even if not requested
+    if( ( p->properties[ PROTOCOLS ] & WMState ) == 0 ) {
+        p->properties[ PROTOCOLS ] |= WMState;
+        unsigned long props[ PROPERTIES_SIZE ] = { WMState, 0 };
+        assert( PROPERTIES_SIZE == 2 ); // add elements above
+        update( props );
+        p->properties[ PROTOCOLS ] &= ~WMState;
+    }
+
+    if (role == Client && p->mapping_state != Withdrawn) {
+
+#ifdef NETWMDEBUG
+        fprintf(stderr, "NETWinInfo::setState (0x%lx, 0x%lx) (Client)\n",
+                state, mask);
+#endif // NETWMDEBUG
+
+	XEvent e;
+	e.xclient.type = ClientMessage;
+	e.xclient.message_type = net_wm_state;
+	e.xclient.display = p->display;
+	e.xclient.window = p->window;
+	e.xclient.format = 32;
+	e.xclient.data.l[3] = 0l;
+	e.xclient.data.l[4] = 0l;
+
+	if ((mask & Modal) && ((p->state & Modal) != (state & Modal))) {
+	    e.xclient.data.l[0] = (state & Modal) ? 1 : 0;
+	    e.xclient.data.l[1] = net_wm_state_modal;
+	    e.xclient.data.l[2] = 0l;
+
+	    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+	}
+
+	if ((mask & Sticky) && ((p->state & Sticky) != (state & Sticky))) {
+	    e.xclient.data.l[0] = (state & Sticky) ? 1 : 0;
+	    e.xclient.data.l[1] = net_wm_state_sticky;
+	    e.xclient.data.l[2] = 0l;
+
+	    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+	}
+
+	if ((mask & Max) && (( (p->state&mask) & Max) != (state & Max))) {
+
+	    unsigned long wishstate = (p->state & ~mask) | (state & mask);
+	    if ( ( (wishstate & MaxHoriz) != (p->state & MaxHoriz) )
+		 && ( (wishstate & MaxVert) != (p->state & MaxVert) ) ) {
+		if ( (wishstate & Max) == Max ) {
+		    e.xclient.data.l[0] = 1;
+		    e.xclient.data.l[1] = net_wm_state_max_horiz;
+		    e.xclient.data.l[2] = net_wm_state_max_vert;
+		    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+		} else if ( (wishstate & Max) == 0 ) {
+		    e.xclient.data.l[0] = 0;
+		    e.xclient.data.l[1] = net_wm_state_max_horiz;
+		    e.xclient.data.l[2] = net_wm_state_max_vert;
+		    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+		} else {
+		    e.xclient.data.l[0] = ( wishstate & MaxHoriz ) ? 1 : 0;
+		    e.xclient.data.l[1] = net_wm_state_max_horiz;
+		    e.xclient.data.l[2] = 0;
+		    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+		    e.xclient.data.l[0] = ( wishstate & MaxVert ) ? 1 : 0;
+		    e.xclient.data.l[1] = net_wm_state_max_vert;
+		    e.xclient.data.l[2] = 0;
+		    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+		}
+	    } else	if ( (wishstate & MaxVert) != (p->state & MaxVert) ) {
+		e.xclient.data.l[0] = ( wishstate & MaxVert ) ? 1 : 0;
+		e.xclient.data.l[1] = net_wm_state_max_vert;
+		e.xclient.data.l[2] = 0;
+		XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+	    } else if ( (wishstate & MaxHoriz) != (p->state & MaxHoriz) ) {
+		e.xclient.data.l[0] = ( wishstate & MaxHoriz ) ? 1 : 0;
+		e.xclient.data.l[1] = net_wm_state_max_horiz;
+		e.xclient.data.l[2] = 0;
+		XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+	    }
+	}
+
+	if ((mask & Shaded) && ((p->state & Shaded) != (state & Shaded))) {
+	    e.xclient.data.l[0] = (state & Shaded) ? 1 : 0;
+	    e.xclient.data.l[1] = net_wm_state_shaded;
+	    e.xclient.data.l[2] = 0l;
+
+	    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+	}
+
+	if ((mask & SkipTaskbar) &&
+	    ((p->state & SkipTaskbar) != (state & SkipTaskbar))) {
+	    e.xclient.data.l[0] = (state & SkipTaskbar) ? 1 : 0;
+	    e.xclient.data.l[1] = net_wm_state_skip_taskbar;
+	    e.xclient.data.l[2] = 0l;
+
+	    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+	}
+
+        if ((mask & SkipPager) &&
+	    ((p->state & SkipPager) != (state & SkipPager))) {
+            e.xclient.data.l[0] = (state & SkipPager) ? 1 : 0;
+            e.xclient.data.l[1] = net_wm_state_skip_pager;
+            e.xclient.data.l[2] = 0l;
+
+            XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+        }
+
+        if ((mask & Hidden) &&
+	    ((p->state & Hidden) != (state & Hidden))) {
+            e.xclient.data.l[0] = (state & Hidden) ? 1 : 0;
+            e.xclient.data.l[1] = net_wm_state_hidden;
+            e.xclient.data.l[2] = 0l;
+
+            XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+        }
+
+        if ((mask & FullScreen) &&
+	    ((p->state & FullScreen) != (state & FullScreen))) {
+            e.xclient.data.l[0] = (state & FullScreen) ? 1 : 0;
+            e.xclient.data.l[1] = net_wm_state_fullscreen;
+            e.xclient.data.l[2] = 0l;
+
+            XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+        }
+
+        if ((mask & KeepAbove) &&
+	    ((p->state & KeepAbove) != (state & KeepAbove))) {
+            e.xclient.data.l[0] = (state & KeepAbove) ? 1 : 0;
+            e.xclient.data.l[1] = net_wm_state_above;
+            e.xclient.data.l[2] = 0l;
+
+            XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+        }
+
+        if ((mask & KeepBelow) &&
+	    ((p->state & KeepBelow) != (state & KeepBelow))) {
+            e.xclient.data.l[0] = (state & KeepBelow) ? 1 : 0;
+            e.xclient.data.l[1] = net_wm_state_below;
+            e.xclient.data.l[2] = 0l;
+
+            XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+        }
+
+	if ((mask & StaysOnTop) && ((p->state & StaysOnTop) != (state & StaysOnTop))) {
+	    e.xclient.data.l[0] = (state & StaysOnTop) ? 1 : 0;
+	    e.xclient.data.l[1] = net_wm_state_stays_on_top;
+	    e.xclient.data.l[2] = 0l;
+
+	    XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+	}
+
+        if ((mask & DemandsAttention) &&
+	    ((p->state & DemandsAttention) != (state & DemandsAttention))) {
+            e.xclient.data.l[0] = (state & DemandsAttention) ? 1 : 0;
+            e.xclient.data.l[1] = net_wm_state_demands_attention;
+            e.xclient.data.l[2] = 0l;
+
+            XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+        }
+
+    } else {
+	p->state &= ~mask;
+	p->state |= state;
+
+	long data[50];
+	int count = 0;
+
+	// hints
+	if (p->state & Modal) data[count++] = net_wm_state_modal;
+	if (p->state & MaxVert) data[count++] = net_wm_state_max_vert;
+	if (p->state & MaxHoriz) data[count++] = net_wm_state_max_horiz;
+	if (p->state & Shaded) data[count++] = net_wm_state_shaded;
+	if (p->state & Hidden) data[count++] = net_wm_state_hidden;
+	if (p->state & FullScreen) data[count++] = net_wm_state_fullscreen;
+	if (p->state & DemandsAttention) data[count++] = net_wm_state_demands_attention;
+
+	// policy
+	if (p->state & KeepAbove) data[count++] = net_wm_state_above;
+	if (p->state & KeepBelow) data[count++] = net_wm_state_below;
+	if (p->state & StaysOnTop) data[count++] = net_wm_state_stays_on_top;
+	if (p->state & Sticky) data[count++] = net_wm_state_sticky;
+	if (p->state & SkipTaskbar) data[count++] = net_wm_state_skip_taskbar;
+	if (p->state & SkipPager) data[count++] = net_wm_state_skip_pager;
+
+#ifdef NETWMDEBUG
+	fprintf(stderr, "NETWinInfo::setState: setting state property (%d)\n", count);
+	for (int i = 0; i < count; i++) {
+            char* data_ret = XGetAtomName(p->display, (Atom) data[i]);
+	    fprintf(stderr, "NETWinInfo::setState:   state %ld '%s'\n",
+		    data[i], data_ret);
+            if ( data_ret )
+                XFree( data_ret );
+        }
+
+#endif
+
+	XChangeProperty(p->display, p->window, net_wm_state, XA_ATOM, 32,
+			PropModeReplace, (unsigned char *) data, count);
+    }
+}
+
+
+void NETWinInfo::setWindowType(WindowType type) {
+    if (role != Client) return;
+
+    int len;
+    long data[2];
+
+    switch (type) {
+    case Override:
+	// spec extension: override window type.  we must comply with the spec
+	// and provide a fall back (normal seems best)
+	data[0] = kde_net_wm_window_type_override;
+	data[1] = net_wm_window_type_normal;
+	len = 2;
+	break;
+
+    case  Dialog:
+	data[0] = net_wm_window_type_dialog;
+	data[1] = None;
+	len = 1;
+	break;
+
+    case Menu:
+	data[0] = net_wm_window_type_menu;
+	data[1] = None;
+	len = 1;
+	break;
+
+    case TopMenu:
+	// spec extension: override window type.  we must comply with the spec
+	// and provide a fall back (dock seems best)
+	data[0] = kde_net_wm_window_type_topmenu;
+	data[1] = net_wm_window_type_dock;
+	len = 2;
+	break;
+
+    case Tool:
+	data[0] = net_wm_window_type_toolbar;
+	data[1] = None;
+	len = 1;
+	break;
+
+    case Dock:
+	data[0] = net_wm_window_type_dock;
+	data[1] = None;
+	len = 1;
+	break;
+
+    case Desktop:
+	data[0] = net_wm_window_type_desktop;
+	data[1] = None;
+	len = 1;
+	break;
+
+    case Utility:
+	data[0] = net_wm_window_type_utility;
+	data[1] = net_wm_window_type_dialog; // fallback for old netwm version
+	len = 2;
+	break;
+
+    case Splash:
+	data[0] = net_wm_window_type_splash;
+	data[1] = net_wm_window_type_dock; // fallback (dock seems best)
+	len = 2;
+	break;
+
+    case DropdownMenu:
+	data[0] = net_wm_window_type_dropdown_menu;
+	data[1] = None;
+	len = 1;
+	break;
+
+    case PopupMenu:
+	data[0] = net_wm_window_type_popup_menu;
+	data[1] = None;
+	len = 1;
+	break;
+
+    case Tooltip:
+	data[0] = net_wm_window_type_tooltip;
+	data[1] = None;
+	len = 1;
+	break;
+
+    case Notification:
+	data[0] = net_wm_window_type_notification;
+	data[1] = None;
+	len = 1;
+	break;
+
+    case ComboBox:
+	data[0] = net_wm_window_type_combobox;
+	data[1] = None;
+	len = 1;
+	break;
+
+    case DNDIcon:
+	data[0] = net_wm_window_type_dnd;
+	data[1] = None;
+	len = 1;
+	break;
+
+    default:
+    case Normal:
+	data[0] = net_wm_window_type_normal;
+	data[1] = None;
+	len = 1;
+	break;
+    }
+
+    XChangeProperty(p->display, p->window, net_wm_window_type, XA_ATOM, 32,
+		    PropModeReplace, (unsigned char *) &data, len);
+}
+
+
+void NETWinInfo::setName(const char *name) {
+    if (role != Client) return;
+
+    delete [] p->name;
+    p->name = nstrdup(name);
+    if( p->name[ 0 ] != '\0' )
+        XChangeProperty(p->display, p->window, net_wm_name, UTF8_STRING, 8,
+		    PropModeReplace, (unsigned char *) p->name,
+		    strlen(p->name));
+    else
+        XDeleteProperty(p->display, p->window, net_wm_name);
+}
+
+
+void NETWinInfo::setVisibleName(const char *visibleName) {
+    if (role != WindowManager) return;
+
+    delete [] p->visible_name;
+    p->visible_name = nstrdup(visibleName);
+    if( p->visible_name[ 0 ] != '\0' )
+        XChangeProperty(p->display, p->window, net_wm_visible_name, UTF8_STRING, 8,
+		    PropModeReplace, (unsigned char *) p->visible_name,
+		    strlen(p->visible_name));
+    else
+        XDeleteProperty(p->display, p->window, net_wm_visible_name);
+}
+
+
+void NETWinInfo::setIconName(const char *iconName) {
+    if (role != Client) return;
+
+    delete [] p->icon_name;
+    p->icon_name = nstrdup(iconName);
+    if( p->icon_name[ 0 ] != '\0' )
+        XChangeProperty(p->display, p->window, net_wm_icon_name, UTF8_STRING, 8,
+		    PropModeReplace, (unsigned char *) p->icon_name,
+		    strlen(p->icon_name));
+    else
+        XDeleteProperty(p->display, p->window, net_wm_icon_name);
+}
+
+
+void NETWinInfo::setVisibleIconName(const char *visibleIconName) {
+    if (role != WindowManager) return;
+
+    delete [] p->visible_icon_name;
+    p->visible_icon_name = nstrdup(visibleIconName);
+    if( p->visible_icon_name[ 0 ] != '\0' )
+        XChangeProperty(p->display, p->window, net_wm_visible_icon_name, UTF8_STRING, 8,
+		    PropModeReplace, (unsigned char *) p->visible_icon_name,
+		    strlen(p->visible_icon_name));
+    else
+        XDeleteProperty(p->display, p->window, net_wm_visible_icon_name);
+}
+
+
+void NETWinInfo::setDesktop(int desktop) {
+    if (p->mapping_state_dirty)
+	updateWMState();
+
+    if (role == Client && p->mapping_state != Withdrawn) {
+	// we only send a ClientMessage if we are 1) a client and 2) managed
+
+	if ( desktop == 0 )
+	    return; // we can't do that while being managed
+
+	XEvent e;
+
+	e.xclient.type = ClientMessage;
+	e.xclient.message_type = net_wm_desktop;
+	e.xclient.display = p->display;
+	e.xclient.window = p->window;
+	e.xclient.format = 32;
+	e.xclient.data.l[0] = desktop == OnAllDesktops ? OnAllDesktops : desktop - 1;
+	e.xclient.data.l[1] = 0l;
+	e.xclient.data.l[2] = 0l;
+	e.xclient.data.l[3] = 0l;
+	e.xclient.data.l[4] = 0l;
+
+	XSendEvent(p->display, p->root, False, netwm_sendevent_mask, &e);
+    } else {
+	// otherwise we just set or remove the property directly
+	p->desktop = desktop;
+	long d = desktop;
+
+	if ( d != OnAllDesktops ) {
+	    if ( d == 0 ) {
+		XDeleteProperty( p->display, p->window, net_wm_desktop );
+		return;
+	    }
+
+	    d -= 1;
+	}
+
+	XChangeProperty(p->display, p->window, net_wm_desktop, XA_CARDINAL, 32,
+			PropModeReplace, (unsigned char *) &d, 1);
+    }
+}
+
+
+void NETWinInfo::setPid(int pid) {
+    if (role != Client) return;
+
+    p->pid = pid;
+    long d = pid;
+    XChangeProperty(p->display, p->window, net_wm_pid, XA_CARDINAL, 32,
+		    PropModeReplace, (unsigned char *) &d, 1);
+}
+
+
+void NETWinInfo::setHandledIcons(Bool handled) {
+    if (role != Client) return;
+
+    p->handled_icons = handled;
+    long d = handled;
+    XChangeProperty(p->display, p->window, net_wm_handled_icons, XA_CARDINAL, 32,
+		    PropModeReplace, (unsigned char *) &d, 1);
+}
+
+void NETWinInfo::setStartupId(const char* id) {
+    if (role != Client) return;
+
+    delete[] p->startup_id;
+    p->startup_id = nstrdup(id);
+    XChangeProperty(p->display, p->window, net_startup_id, UTF8_STRING, 8,
+        PropModeReplace, reinterpret_cast< unsigned char* >( p->startup_id ),
+        strlen( p->startup_id ));
+}
+
+void NETWinInfo::setAllowedActions( unsigned long actions ) {
+    if( role != WindowManager )
+        return;
+    long data[50];
+    int count = 0;
+
+    p->allowed_actions = actions;
+    if (p->allowed_actions & ActionMove) data[count++] = net_wm_action_move;
+    if (p->allowed_actions & ActionResize) data[count++] = net_wm_action_resize;
+    if (p->allowed_actions & ActionMinimize) data[count++] = net_wm_action_minimize;
+    if (p->allowed_actions & ActionShade) data[count++] = net_wm_action_shade;
+    if (p->allowed_actions & ActionStick) data[count++] = net_wm_action_stick;
+    if (p->allowed_actions & ActionMaxVert) data[count++] = net_wm_action_max_vert;
+    if (p->allowed_actions & ActionMaxHoriz) data[count++] = net_wm_action_max_horiz;
+    if (p->allowed_actions & ActionFullScreen) data[count++] = net_wm_action_fullscreen;
+    if (p->allowed_actions & ActionChangeDesktop) data[count++] = net_wm_action_change_desk;
+    if (p->allowed_actions & ActionClose) data[count++] = net_wm_action_close;
+
+#ifdef NETWMDEBUG
+    fprintf(stderr, "NETWinInfo::setAllowedActions: setting property (%d)\n", count);
+    for (int i = 0; i < count; i++) {
+        char* data_ret = XGetAtomName(p->display, (Atom) data[i]);
+        fprintf(stderr, "NETWinInfo::setAllowedActions:   action %ld '%s'\n",
+	    data[i], data_ret);
+        if ( data_ret )
+            XFree(data_ret);
+    }
+#endif
+
+    XChangeProperty(p->display, p->window, net_wm_allowed_actions, XA_ATOM, 32,
+		    PropModeReplace, (unsigned char *) data, count);
+}
+
+void NETWinInfo::setKDESystemTrayWinFor(Window window) {
+    if (role != Client) return;
+
+    p->kde_system_tray_win_for = window;
+    XChangeProperty(p->display, p->window, kde_net_wm_system_tray_window_for,
+		    XA_WINDOW, 32, PropModeReplace,
+		    (unsigned char *) &(p->kde_system_tray_win_for), 1);
+}
+
+
+void NETWinInfo::setKDEFrameStrut(NETStrut strut) {
+    setFrameExtents( strut );
+}
+
+void NETWinInfo::setFrameExtents(NETStrut strut) {
+    if (role != WindowManager) return;
+
+    p->frame_strut = strut;
+
+    long d[4];
+    d[0] = strut.left;
+    d[1] = strut.right;
+    d[2] = strut.top;
+    d[3] = strut.bottom;
+
+    XChangeProperty(p->display, p->window, net_frame_extents, XA_CARDINAL, 32,
+		    PropModeReplace, (unsigned char *) d, 4);
+    XChangeProperty(p->display, p->window, kde_net_wm_frame_strut, XA_CARDINAL, 32,
+		    PropModeReplace, (unsigned char *) d, 4);
+}
+
+
+void NETWinInfo::kdeGeometry(NETRect& frame, NETRect& window) {
+    if (p->win_geom.size.width == 0 || p->win_geom.size.height == 0) {
+	Window unused;
+	int x, y;
+	unsigned int w, h, junk;
+	XGetGeometry(p->display, p->window, &unused, &x, &y, &w, &h, &junk, &junk);
+	XTranslateCoordinates(p->display, p->window, p->root, 0, 0, &x, &y, &unused
+			      );
+
+	p->win_geom.pos.x = x;
+	p->win_geom.pos.y = y;
+
+	p->win_geom.size.width = w;
+	p->win_geom.size.height = h;
+    }
+// TODO try to work also without _KDE_NET_WM_FRAME_STRUT
+    window = p->win_geom;
+
+    frame.pos.x = window.pos.x - p->frame_strut.left;
+    frame.pos.y = window.pos.y - p->frame_strut.top;
+    frame.size.width = window.size.width + p->frame_strut.left + p->frame_strut.right;
+    frame.size.height = window.size.height + p->frame_strut.top + p->frame_strut.bottom;
+}
+
+
+NETIcon NETWinInfo::icon(int width, int height) const {
+    return iconInternal( p->icons, p->icon_count, width, height );
+}
+
+NETIcon NETWinInfo::iconInternal(NETRArray<NETIcon>& icons, int icon_count, int width, int height) const {
+    NETIcon result;
+
+    if ( !icon_count ) {
+	result.size.width = 0;
+	result.size.height = 0;
+	result.data = 0;
+	return result;
+    }
+
+    // find the largest icon
+    result = icons[0];
+    for (int i = 1; i < icons.size(); i++) {
+	if( icons[i].size.width >= result.size.width &&
+	     icons[i].size.height >= result.size.height )
+	    result = icons[i];
+    }
+
+    // return the largest icon if w and h are -1
+    if (width == -1 && height == -1) return result;
+
+    // find the icon that's closest in size to w x h...
+    for (int i = 0; i < icons.size(); i++) {
+	if ((icons[i].size.width >= width &&
+	     icons[i].size.width < result.size.width) &&
+	    (icons[i].size.height >= height &&
+	     icons[i].size.height < result.size.height))
+	    result = icons[i];
+    }
+
+    return result;
+}
+
+void NETWinInfo::setUserTime( Time time ) {
+    if (role != Client) return;
+
+    p->user_time = time;
+    long d = time;
+    XChangeProperty(p->display, p->window, net_wm_user_time, XA_CARDINAL, 32,
+		    PropModeReplace, (unsigned char *) &d, 1);
+}
+
+
+unsigned long NETWinInfo::event(XEvent *ev )
+{
+    unsigned long props[ 1 ];
+    event( ev, props, 1 );
+    return props[ 0 ];
+}
+
+void NETWinInfo::event(XEvent *event, unsigned long* properties, int properties_size ) {
+    unsigned long props[ PROPERTIES_SIZE ] = { 0, 0 };
+    assert( PROPERTIES_SIZE == 2 ); // add elements above
+    unsigned long& dirty = props[ PROTOCOLS ];
+    unsigned long& dirty2 = props[ PROTOCOLS2 ];
+    bool do_update = false;
+
+    if (role == WindowManager && event->type == ClientMessage &&
+	event->xclient.format == 32) {
+
+#ifdef NETWMDEBUG
+        fprintf(stderr, "NETWinInfo::event: handling ClientMessage event\n");
+#endif // NETWMDEBUG
+
+	if (event->xclient.message_type == net_wm_state) {
+	    dirty = WMState;
+
+	    // we need to generate a change mask
+
+#ifdef NETWMDEBUG
+	    fprintf(stderr,
+		    "NETWinInfo::event: state client message, getting new state/mask\n");
+#endif
+
+	    int i;
+	    long state = 0, mask = 0;
+
+	    for (i = 1; i < 3; i++) {
+#ifdef NETWMDEBUG
+                char* debug_txt = XGetAtomName(p->display, (Atom) event->xclient.data.l[i]);
+		fprintf(stderr, "NETWinInfo::event:  message %ld '%s'\n",
+			event->xclient.data.l[i], debug_txt );
+                if ( debug_txt )
+                    XFree( debug_txt );
+#endif
+
+		if ((Atom) event->xclient.data.l[i] == net_wm_state_modal)
+		    mask |= Modal;
+		else if ((Atom) event->xclient.data.l[i] == net_wm_state_sticky)
+		    mask |= Sticky;
+		else if ((Atom) event->xclient.data.l[i] == net_wm_state_max_vert)
+		    mask |= MaxVert;
+		else if ((Atom) event->xclient.data.l[i] == net_wm_state_max_horiz)
+		    mask |= MaxHoriz;
+		else if ((Atom) event->xclient.data.l[i] == net_wm_state_shaded)
+		    mask |= Shaded;
+		else if ((Atom) event->xclient.data.l[i] == net_wm_state_skip_taskbar)
+		    mask |= SkipTaskbar;
+                else if ((Atom) event->xclient.data.l[i] == net_wm_state_skip_pager)
+		    mask |= SkipPager;
+                else if ((Atom) event->xclient.data.l[i] == net_wm_state_hidden)
+		    mask |= Hidden;
+                else if ((Atom) event->xclient.data.l[i] == net_wm_state_fullscreen)
+		    mask |= FullScreen;
+                else if ((Atom) event->xclient.data.l[i] == net_wm_state_above)
+		    mask |= KeepAbove;
+                else if ((Atom) event->xclient.data.l[i] == net_wm_state_below)
+		    mask |= KeepBelow;
+                else if ((Atom) event->xclient.data.l[i] == net_wm_state_demands_attention)
+		    mask |= DemandsAttention;
+		else if ((Atom) event->xclient.data.l[i] == net_wm_state_stays_on_top)
+		    mask |= StaysOnTop;
+	    }
+
+	    // when removing, we just leave newstate == 0
+	    switch (event->xclient.data.l[0]) {
+	    case 1: // set
+		// to set... the change state should be the same as the mask
+		state = mask;
+		break;
+
+	    case 2: // toggle
+		// to toggle, we need to xor the current state with the new state
+		state = (p->state & mask) ^ mask;
+		break;
+
+	    default:
+		// to clear state, the new state should stay zero
+		;
+	    }
+
+#ifdef NETWMDEBUG
+	    fprintf(stderr, "NETWinInfo::event: calling changeState(%lx, %lx)\n",
+		    state, mask);
+#endif
+
+	    changeState(state, mask);
+	} else if (event->xclient.message_type == net_wm_desktop) {
+	    dirty = WMDesktop;
+
+	    if( event->xclient.data.l[0] == OnAllDesktops )
+		changeDesktop( OnAllDesktops );
+	    else
+    		changeDesktop(event->xclient.data.l[0] + 1);
+	}
+    }
+
+    if (event->type == PropertyNotify) {
+
+#ifdef    NETWMDEBUG
+	fprintf(stderr, "NETWinInfo::event: handling PropertyNotify event\n");
+#endif
+
+	XEvent pe = *event;
+
+	Bool done = False;
+	Bool compaction = False;
+	while (! done) {
+
+#ifdef    NETWMDEBUG
+	    fprintf(stderr, "NETWinInfo::event: loop fire\n");
+#endif
+
+	    if (pe.xproperty.atom == net_wm_name)
+		dirty |= WMName;
+	    else if (pe.xproperty.atom == net_wm_visible_name)
+		dirty |= WMVisibleName;
+	    else if (pe.xproperty.atom == net_wm_desktop)
+		dirty |= WMDesktop;
+	    else if (pe.xproperty.atom == net_wm_window_type)
+		dirty |=WMWindowType;
+	    else if (pe.xproperty.atom == net_wm_state)
+		dirty |= WMState;
+	    else if (pe.xproperty.atom == net_wm_strut)
+		dirty |= WMStrut;
+	    else if (pe.xproperty.atom == net_wm_extended_strut)
+		dirty2 |= WM2ExtendedStrut;
+	    else if (pe.xproperty.atom == net_wm_icon_geometry)
+		dirty |= WMIconGeometry;
+	    else if (pe.xproperty.atom == net_wm_icon)
+		dirty |= WMIcon;
+	    else if (pe.xproperty.atom == net_wm_pid)
+		dirty |= WMPid;
+	    else if (pe.xproperty.atom == net_wm_handled_icons)
+		dirty |= WMHandledIcons;
+	    else if (pe.xproperty.atom == net_startup_id)
+		dirty2 |= WM2StartupId;
+	    else if (pe.xproperty.atom == net_wm_allowed_actions)
+		dirty2 |= WM2AllowedActions;
+	    else if (pe.xproperty.atom == kde_net_wm_system_tray_window_for)
+		dirty |= WMKDESystemTrayWinFor;
+	    else if (pe.xproperty.atom == xa_wm_state)
+		dirty |= XAWMState;
+	    else if (pe.xproperty.atom == net_frame_extents)
+		dirty |= WMFrameExtents;
+	    else if (pe.xproperty.atom == kde_net_wm_frame_strut)
+		dirty |= WMKDEFrameStrut;
+	    else if (pe.xproperty.atom == net_wm_icon_name)
+		dirty |= WMIconName;
+	    else if (pe.xproperty.atom == net_wm_visible_icon_name)
+		dirty |= WMVisibleIconName;
+	    else if (pe.xproperty.atom == net_wm_user_time)
+		dirty2 |= WM2UserTime;
+            else if (pe.xproperty.atom == XA_WM_HINTS)
+                dirty2 |= WM2GroupLeader;
+            else if (pe.xproperty.atom == XA_WM_TRANSIENT_FOR)
+                dirty2 |= WM2TransientFor;
+            else if (pe.xproperty.atom == XA_WM_CLASS)
+                dirty2 |= WM2WindowClass;
+            else if (pe.xproperty.atom == wm_window_role)
+                dirty2 |= WM2WindowRole;
+            else if (pe.xproperty.atom == XA_WM_CLIENT_MACHINE)
+                dirty2 |= WM2ClientMachine;
+	    else {
+
+#ifdef    NETWMDEBUG
+		fprintf(stderr, "NETWinInfo::event: putting back event and breaking\n");
+#endif
+
+		if ( compaction )
+		    XPutBackEvent(p->display, &pe);
+		break;
+	    }
+
+	    if (XCheckTypedWindowEvent(p->display, p->window, PropertyNotify, &pe) )
+		compaction = True;
+	    else
+		break;
+	}
+
+	do_update = true;
+    } else if (event->type == ConfigureNotify) {
+
+#ifdef NETWMDEBUG
+	fprintf(stderr, "NETWinInfo::event: handling ConfigureNotify event\n");
+#endif
+
+	dirty |= WMGeometry;
+
+	// update window geometry
+	p->win_geom.pos.x = event->xconfigure.x;
+	p->win_geom.pos.y = event->xconfigure.y;
+	p->win_geom.size.width = event->xconfigure.width;
+	p->win_geom.size.height = event->xconfigure.height;
+    }
+
+    if( do_update )
+        update( props );
+
+    if( properties_size > PROPERTIES_SIZE )
+        properties_size = PROPERTIES_SIZE;
+    for( int i = 0;
+         i < properties_size;
+         ++i )
+        properties[ i ] = props[ i ];
+}
+
+void NETWinInfo::updateWMState() {
+    unsigned long props[ PROPERTIES_SIZE ] = { XAWMState, 0 };
+    assert( PROPERTIES_SIZE == 2 ); // add elements above
+    update( props );
+}
+
+void NETWinInfo::update(const unsigned long dirty_props[]) {
+    Atom type_ret;
+    int format_ret;
+    unsigned long nitems_ret, unused;
+    unsigned char *data_ret;
+    unsigned long props[ PROPERTIES_SIZE ];
+    for( int i = 0;
+         i < PROPERTIES_SIZE;
+         ++i )
+        props[ i ] = dirty_props[ i ] & p->properties[ i ];
+    const unsigned long& dirty = props[ PROTOCOLS ];
+    const unsigned long& dirty2 = props[ PROTOCOLS2 ];
+
+    // we *always* want to update WM_STATE if set in dirty_props
+    if( dirty_props[ PROTOCOLS ] & XAWMState )
+        props[ PROTOCOLS ] |= XAWMState;
+
+    if (dirty & XAWMState) {
+        p->mapping_state = Withdrawn;
+	if (XGetWindowProperty(p->display, p->window, xa_wm_state, 0l, 1l,
+			       False, xa_wm_state, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == xa_wm_state && format_ret == 32 &&
+		nitems_ret == 1) {
+		long *state = (long *) data_ret;
+
+		switch(*state) {
+		    case IconicState:
+			p->mapping_state = Iconic;
+			break;
+		    case NormalState:
+			p->mapping_state = Visible;
+                        break;
+		    case WithdrawnState:
+		    default:
+			p->mapping_state = Withdrawn;
+			break;
+		}
+
+		p->mapping_state_dirty = False;
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMState) {
+	p->state = 0;
+	if (XGetWindowProperty(p->display, p->window, net_wm_state, 0l, 2048l,
+			       False, XA_ATOM, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_ATOM && format_ret == 32 && nitems_ret > 0) {
+		// determine window state
+#ifdef NETWMDEBUG
+		fprintf(stderr, "NETWinInfo::update: updating window state (%ld)\n",
+			nitems_ret);
+#endif
+
+		long *states = (long *) data_ret;
+		unsigned long count;
+
+		for (count = 0; count < nitems_ret; count++) {
+#ifdef NETWMDEBUG
+                    char* data_ret = XGetAtomName(p->display, (Atom) states[count]);
+		    fprintf(stderr,
+			    "NETWinInfo::update:   adding window state %ld '%s'\n",
+			    states[count], data_ret );
+                    if ( data_ret )
+                        XFree( data_ret );
+#endif
+
+		    if ((Atom) states[count] == net_wm_state_modal)
+			p->state |= Modal;
+		    else if ((Atom) states[count] == net_wm_state_sticky)
+			p->state |= Sticky;
+		    else if ((Atom) states[count] == net_wm_state_max_vert)
+			p->state |= MaxVert;
+		    else if ((Atom) states[count] == net_wm_state_max_horiz)
+			p->state |= MaxHoriz;
+		    else if ((Atom) states[count] == net_wm_state_shaded)
+			p->state |= Shaded;
+		    else if ((Atom) states[count] == net_wm_state_skip_taskbar)
+			p->state |= SkipTaskbar;
+		    else if ((Atom) states[count] == net_wm_state_skip_pager)
+			p->state |= SkipPager;
+		    else if ((Atom) states[count] == net_wm_state_hidden)
+			p->state |= Hidden;
+		    else if ((Atom) states[count] == net_wm_state_fullscreen)
+			p->state |= FullScreen;
+		    else if ((Atom) states[count] == net_wm_state_above)
+			p->state |= KeepAbove;
+		    else if ((Atom) states[count] == net_wm_state_below)
+			p->state |= KeepBelow;
+		    else if ((Atom) states[count] == net_wm_state_demands_attention)
+			p->state |= DemandsAttention;
+		    else if ((Atom) states[count] == net_wm_state_stays_on_top)
+			p->state |= StaysOnTop;
+		}
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMDesktop) {
+	p->desktop = 0;
+	if (XGetWindowProperty(p->display, p->window, net_wm_desktop, 0l, 1l,
+			       False, XA_CARDINAL, &type_ret,
+			       &format_ret, &nitems_ret,
+			       &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 &&
+		nitems_ret == 1) {
+		p->desktop = *((long *) data_ret);
+		if ((signed) p->desktop != OnAllDesktops)
+		    p->desktop++;
+
+		if ( p->desktop == 0 )
+		    p->desktop = OnAllDesktops;
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMName) {
+        delete[] p->name;
+        p->name = NULL;
+	if (XGetWindowProperty(p->display, p->window, net_wm_name, 0l,
+			       MAX_PROP_SIZE, False, UTF8_STRING, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == UTF8_STRING && format_ret == 8 && nitems_ret > 0) {
+		p->name = nstrndup((const char *) data_ret, nitems_ret);
+	    }
+
+	    if( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMVisibleName) {
+        delete[] p->visible_name;
+        p->visible_name = NULL;
+	if (XGetWindowProperty(p->display, p->window, net_wm_visible_name, 0l,
+			       MAX_PROP_SIZE, False, UTF8_STRING, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == UTF8_STRING && format_ret == 8 && nitems_ret > 0) {
+		p->visible_name = nstrndup((const char *) data_ret, nitems_ret);
+	    }
+
+	    if( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMIconName) {
+        delete[] p->icon_name;
+        p->icon_name = NULL;
+	if (XGetWindowProperty(p->display, p->window, net_wm_icon_name, 0l,
+			       MAX_PROP_SIZE, False, UTF8_STRING, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == UTF8_STRING && format_ret == 8 && nitems_ret > 0) {
+		p->icon_name = nstrndup((const char *) data_ret, nitems_ret);
+	    }
+
+	    if( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMVisibleIconName)
+    {
+        delete[] p->visible_icon_name;
+        p->visible_icon_name = NULL;
+	if (XGetWindowProperty(p->display, p->window, net_wm_visible_icon_name, 0l,
+			       MAX_PROP_SIZE, False, UTF8_STRING, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == UTF8_STRING && format_ret == 8 && nitems_ret > 0) {
+		p->visible_icon_name = nstrndup((const char *) data_ret, nitems_ret);
+	    }
+
+	    if( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMWindowType) {
+	p->types.reset();
+	p->types[ 0 ] = Unknown;
+        p->has_net_support = false;
+	if (XGetWindowProperty(p->display, p->window, net_wm_window_type, 0l, 2048l,
+			       False, XA_ATOM, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_ATOM && format_ret == 32 && nitems_ret > 0) {
+		// determine the window type
+#ifdef NETWMDEBUG
+		fprintf(stderr, "NETWinInfo::update: getting window type (%ld)\n",
+			nitems_ret);
+#endif
+
+                p->has_net_support = true;
+
+		unsigned long count = 0;
+		long *types = (long *) data_ret;
+		int pos = 0;
+
+		while (count < nitems_ret) {
+		    // remember all window types we know
+#ifdef NETWMDEBUG
+                    char* debug_type = XGetAtomName(p->display, (Atom) types[count]);
+		    fprintf(stderr,
+			    "NETWinInfo::update:   examining window type %ld %s\n",
+			    types[count], debug_type );
+                    if ( debug_type )
+                        XFree( debug_type );
+#endif
+
+		    if ((Atom) types[count] == net_wm_window_type_normal)
+			p->types[ pos++ ] = Normal;
+		    else if ((Atom) types[count] == net_wm_window_type_desktop)
+			p->types[ pos++ ] = Desktop;
+		    else if ((Atom) types[count] == net_wm_window_type_dock)
+			p->types[ pos++ ] = Dock;
+		    else if ((Atom) types[count] == net_wm_window_type_toolbar)
+			p->types[ pos++ ] = Tool;
+		    else if ((Atom) types[count] == net_wm_window_type_menu)
+			p->types[ pos++ ] = Menu;
+		    else if ((Atom) types[count] == net_wm_window_type_dialog)
+			p->types[ pos++ ] = Dialog;
+		    else if ((Atom) types[count] == net_wm_window_type_utility)
+			p->types[ pos++ ] = Utility;
+		    else if ((Atom) types[count] == net_wm_window_type_splash)
+			p->types[ pos++ ] = Splash;
+		    else if ((Atom) types[count] == net_wm_window_type_dropdown_menu)
+			p->types[ pos++ ] = DropdownMenu;
+		    else if ((Atom) types[count] == net_wm_window_type_popup_menu)
+			p->types[ pos++ ] = PopupMenu;
+		    else if ((Atom) types[count] == net_wm_window_type_tooltip)
+			p->types[ pos++ ] = Tooltip;
+		    else if ((Atom) types[count] == net_wm_window_type_notification)
+			p->types[ pos++ ] = Notification;
+		    else if ((Atom) types[count] == net_wm_window_type_combobox)
+			p->types[ pos++ ] = ComboBox;
+		    else if ((Atom) types[count] == net_wm_window_type_dnd)
+			p->types[ pos++ ] = DNDIcon;
+		    else if ((Atom) types[count] == kde_net_wm_window_type_override)
+			p->types[ pos++ ] = Override;
+		    else if ((Atom) types[count] == kde_net_wm_window_type_topmenu)
+			p->types[ pos++ ] = TopMenu;
+
+		    count++;
+		}
+	    }
+
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMStrut) {
+        p->strut = NETStrut();
+	if (XGetWindowProperty(p->display, p->window, net_wm_strut, 0l, 4l,
+			       False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 &&
+		nitems_ret == 4) {
+		long *d = (long *) data_ret;
+		p->strut.left   = d[0];
+		p->strut.right  = d[1];
+		p->strut.top    = d[2];
+		p->strut.bottom = d[3];
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty2 & WM2ExtendedStrut) {
+        p->extended_strut = NETExtendedStrut();
+	if (XGetWindowProperty(p->display, p->window, net_wm_extended_strut, 0l, 12l,
+			       False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 &&
+		nitems_ret == 12) {
+		long *d = (long *) data_ret;
+		p->extended_strut.left_width = d[0];
+		p->extended_strut.right_width = d[1];
+		p->extended_strut.top_width = d[2];
+		p->extended_strut.bottom_width = d[3];
+                p->extended_strut.left_start = d[4];
+                p->extended_strut.left_end = d[5];
+                p->extended_strut.right_start = d[6];
+                p->extended_strut.right_end = d[7];
+                p->extended_strut.top_start = d[8];
+                p->extended_strut.top_end = d[9];
+                p->extended_strut.bottom_start = d[10];
+                p->extended_strut.bottom_end = d[11];
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMIconGeometry) {
+        p->icon_geom = NETRect();
+	if (XGetWindowProperty(p->display, p->window, net_wm_icon_geometry, 0l, 4l,
+			       False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 &&
+		nitems_ret == 4) {
+		long *d = (long *) data_ret;
+		p->icon_geom.pos.x       = d[0];
+		p->icon_geom.pos.y       = d[1];
+		p->icon_geom.size.width  = d[2];
+		p->icon_geom.size.height = d[3];
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMIcon) {
+	readIcon(p->display,p->window,net_wm_icon,p->icons,p->icon_count);
+    }
+
+    if (dirty & WMKDESystemTrayWinFor) {
+	p->kde_system_tray_win_for = 0;
+	if (XGetWindowProperty(p->display, p->window, kde_net_wm_system_tray_window_for,
+			       0l, 1l, False, XA_WINDOW, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_WINDOW && format_ret == 32 &&
+		nitems_ret == 1) {
+		p->kde_system_tray_win_for = *((Window *) data_ret);
+		if ( p->kde_system_tray_win_for == 0 )
+		    p->kde_system_tray_win_for = p->root;
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+        }
+    }
+
+    if (dirty & WMFrameExtents) {
+        p->frame_strut = NETStrut();
+        bool ok = false;
+	if (XGetWindowProperty(p->display, p->window, net_frame_extents,
+			       0l, 4l, False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret) == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 && nitems_ret == 4) {
+                ok = true;
+		long *d = (long *) data_ret;
+
+		p->frame_strut.left   = d[0];
+		p->frame_strut.right  = d[1];
+		p->frame_strut.top    = d[2];
+		p->frame_strut.bottom = d[3];
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+        }
+	if (!ok && XGetWindowProperty(p->display, p->window, kde_net_wm_frame_strut,
+			       0l, 4l, False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret) == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 && nitems_ret == 4) {
+                ok = true;
+		long *d = (long *) data_ret;
+
+		p->frame_strut.left   = d[0];
+		p->frame_strut.right  = d[1];
+		p->frame_strut.top    = d[2];
+		p->frame_strut.bottom = d[3];
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty & WMPid) {
+	p->pid = 0;
+	if (XGetWindowProperty(p->display, p->window, net_wm_pid, 0l, 1l,
+			       False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret) == Success) {
+	    if (type_ret == XA_CARDINAL && format_ret == 32 && nitems_ret == 1) {
+		p->pid = *((long *) data_ret);
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty2 & WM2StartupId)
+    {
+        delete[] p->startup_id;
+        p->startup_id = NULL;
+	if (XGetWindowProperty(p->display, p->window, net_startup_id, 0l,
+			       MAX_PROP_SIZE, False, UTF8_STRING, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == UTF8_STRING && format_ret == 8 && nitems_ret > 0) {
+		p->startup_id = nstrndup((const char *) data_ret, nitems_ret);
+	    }
+
+	    if( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if( dirty2 & WM2AllowedActions ) {
+        p->allowed_actions = 0;
+	if (XGetWindowProperty(p->display, p->window, net_wm_allowed_actions, 0l, 2048l,
+			       False, XA_ATOM, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_ATOM && format_ret == 32 && nitems_ret > 0) {
+		// determine actions
+#ifdef NETWMDEBUG
+		fprintf(stderr, "NETWinInfo::update: updating allowed actions (%ld)\n",
+			nitems_ret);
+#endif
+
+		long *actions = (long *) data_ret;
+		unsigned long count;
+
+		for (count = 0; count < nitems_ret; count++) {
+#ifdef NETWMDEBUG
+		    fprintf(stderr,
+			    "NETWinInfo::update:   adding allowed action %ld '%s'\n",
+			    actions[count],
+			    XGetAtomName(p->display, (Atom) actions[count]));
+#endif
+
+		    if ((Atom) actions[count] == net_wm_action_move)
+			p->allowed_actions |= ActionMove;
+		    if ((Atom) actions[count] == net_wm_action_resize)
+			p->allowed_actions |= ActionResize;
+		    if ((Atom) actions[count] == net_wm_action_minimize)
+			p->allowed_actions |= ActionMinimize;
+		    if ((Atom) actions[count] == net_wm_action_shade)
+			p->allowed_actions |= ActionShade;
+		    if ((Atom) actions[count] == net_wm_action_stick)
+			p->allowed_actions |= ActionStick;
+		    if ((Atom) actions[count] == net_wm_action_max_vert)
+			p->allowed_actions |= ActionMaxVert;
+		    if ((Atom) actions[count] == net_wm_action_max_horiz)
+			p->allowed_actions |= ActionMaxHoriz;
+		    if ((Atom) actions[count] == net_wm_action_fullscreen)
+			p->allowed_actions |= ActionFullScreen;
+		    if ((Atom) actions[count] == net_wm_action_change_desk)
+			p->allowed_actions |= ActionChangeDesktop;
+		    if ((Atom) actions[count] == net_wm_action_close)
+			p->allowed_actions |= ActionClose;
+		}
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty2 & WM2UserTime) {
+	p->user_time = -1U;
+	if (XGetWindowProperty(p->display, p->window, net_wm_user_time, 0l, 1l,
+			       False, XA_CARDINAL, &type_ret, &format_ret,
+			       &nitems_ret, &unused, &data_ret) == Success) {
+            // don't do nitems_ret check - Qt does PropModeAppend to avoid API call for it
+	    if (type_ret == XA_CARDINAL && format_ret == 32 /*&& nitems_ret == 1*/) {
+		p->user_time = *((long *) data_ret);
+	    }
+	    if ( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if (dirty2 & WM2TransientFor) {
+	p->transient_for = None;
+        XGetTransientForHint(p->display, p->window, &p->transient_for);
+    }
+
+    if (dirty2 & WM2GroupLeader) {
+        XWMHints *hints = XGetWMHints(p->display, p->window);
+        p->window_group = None;
+        if ( hints )
+        {
+            if( hints->flags & WindowGroupHint )
+                p->window_group = hints->window_group;
+            XFree( reinterpret_cast< char* >( hints ));
+        }
+    }
+    
+    if( dirty2 & WM2WindowClass ) {
+        delete[] p->class_class;
+        delete[] p->class_name;
+        p->class_class = NULL;
+        p->class_name = NULL;
+        XClassHint hint;
+        if( XGetClassHint( p->display, p->window, &hint )) {
+            p->class_class = strdup( hint.res_class );
+            p->class_name = strdup( hint.res_name );
+            XFree( hint.res_class );
+            XFree( hint.res_name );
+        }
+    }
+
+    if( dirty2 & WM2WindowRole ) {
+        delete[] p->role;
+        p->role = NULL;
+	if (XGetWindowProperty(p->display, p->window, wm_window_role, 0l,
+			       MAX_PROP_SIZE, False, XA_STRING, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_STRING && format_ret == 8 && nitems_ret > 0) {
+		p->role = nstrndup((const char *) data_ret, nitems_ret);
+	    }
+	    if( data_ret )
+		XFree(data_ret);
+	}
+    }
+
+    if( dirty2 & WM2ClientMachine ) {
+        delete[] p->client_machine;
+        p->client_machine = NULL;
+	if (XGetWindowProperty(p->display, p->window, XA_WM_CLIENT_MACHINE, 0l,
+			       MAX_PROP_SIZE, False, XA_STRING, &type_ret,
+			       &format_ret, &nitems_ret, &unused, &data_ret)
+	    == Success) {
+	    if (type_ret == XA_STRING && format_ret == 8 && nitems_ret > 0) {
+		p->client_machine = nstrndup((const char *) data_ret, nitems_ret);
+	    }
+	    if( data_ret )
+		XFree(data_ret);
+	}
+    }
+}
+
+
+NETRect NETWinInfo::iconGeometry() const {
+    return p->icon_geom;
+}
+
+
+unsigned long NETWinInfo::state() const {
+    return p->state;
+}
+
+
+NETStrut NETWinInfo::strut() const {
+    return p->strut;
+}
+
+NETExtendedStrut NETWinInfo::extendedStrut() const {
+    return p->extended_strut;
+}
+
+bool NET::typeMatchesMask( WindowType type, unsigned long mask ) {
+    switch( type ) {
+#define CHECK_TYPE_MASK( type ) \
+        case type: \
+    	    if( mask & type##Mask ) \
+	        return true; \
+	    break;
+        CHECK_TYPE_MASK( Normal )
+        CHECK_TYPE_MASK( Desktop )
+        CHECK_TYPE_MASK( Dock )
+        CHECK_TYPE_MASK( Toolbar )
+        CHECK_TYPE_MASK( Menu )
+        CHECK_TYPE_MASK( Dialog )
+        CHECK_TYPE_MASK( Override )
+        CHECK_TYPE_MASK( TopMenu )
+        CHECK_TYPE_MASK( Utility )
+        CHECK_TYPE_MASK( Splash )
+        CHECK_TYPE_MASK( DropdownMenu )
+        CHECK_TYPE_MASK( PopupMenu )
+        CHECK_TYPE_MASK( Tooltip )
+        CHECK_TYPE_MASK( Notification )
+        CHECK_TYPE_MASK( ComboBox )
+        CHECK_TYPE_MASK( DNDIcon )
+#undef CHECK_TYPE_MASK
+        default:
+            break;
+    }
+    return false;
+}
+
+NET::WindowType NETWinInfo::windowType( unsigned long supported_types ) const {
+    for( int i = 0;
+	 i < p->types.size();
+	 ++i ) {
+	// return the type only if the application supports it
+        if( typeMatchesMask( p->types[ i ], supported_types ))
+            return p->types[ i ];
+	}
+    return Unknown;
+}
+
+NET::WindowType NETWinInfo::windowType() const {
+    return p->types[ 0 ];
+}
+
+
+const char *NETWinInfo::name() const {
+    return p->name;
+}
+
+
+const char *NETWinInfo::visibleName() const {
+    return p->visible_name;
+}
+
+
+const char *NETWinInfo::iconName() const {
+    return p->icon_name;
+}
+
+
+const char *NETWinInfo::visibleIconName() const {
+    return p->visible_icon_name;
+}
+
+
+int NETWinInfo::desktop() const {
+    return p->desktop;
+}
+
+int NETWinInfo::pid() const {
+    return p->pid;
+}
+
+Time NETWinInfo::userTime() const {
+    return p->user_time;
+}
+
+const char* NETWinInfo::startupId() const {
+    return p->startup_id;
+}
+
+unsigned long NETWinInfo::allowedActions() const {
+    return p->allowed_actions;
+}
+
+bool NETWinInfo::hasNETSupport() const {
+    return p->has_net_support;
+}
+
+Window NETWinInfo::transientFor() const {
+    return p->transient_for;
+}
+
+Window NETWinInfo::groupLeader() const {
+    return p->window_group;
+}
+
+const char* NETWinInfo::windowClassClass() const {
+    return p->class_class;
+}
+
+const char* NETWinInfo::windowClassName() const {
+    return p->class_name;
+}
+
+const char* NETWinInfo::windowRole() const {
+    return p->role;
+}
+
+const char* NETWinInfo::clientMachine() const {
+    return p->client_machine;
+}
+
+Bool NETWinInfo::handledIcons() const {
+    return p->handled_icons;
+}
+
+
+Window NETWinInfo::kdeSystemTrayWinFor() const {
+    return p->kde_system_tray_win_for;
+}
+
+const unsigned long* NETWinInfo::passedProperties() const {
+    return p->properties;
+}
+
+unsigned long NETWinInfo::properties() const {
+    return p->properties[ PROTOCOLS ];
+}
+
+
+NET::MappingState NETWinInfo::mappingState() const {
+    return p->mapping_state;
+}
+
+void NETRootInfo::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+void NETWinInfo::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+// Functions for X timestamp comparing. For Time being 32bit they're fairly simple
+// (the #if 0 part), but on 64bit architectures Time is 64bit unsigned long,
+// so there special care needs to be taken to always use only the lower 32bits.
+#if 0
+int NET::timestampCompare( Time time1, Time time2 ) // like strcmp()
+    {
+    if( time1 == time2 )
+        return 0;
+    return ( time1 - time2 ) < 0x7fffffffU ? 1 : -1; // time1 > time2 -> 1, handle wrapping
+    }
+
+Time NET::timestampDiff( Time time1, Time time2 ) // returns time2 - time1
+    { // no need to handle wrapping?
+    return time2 - time1;
+    }
+#else
+int NET::timestampCompare( unsigned long time1_, unsigned long time2_ ) // like strcmp()
+    {
+    TQ_UINT32 time1 = time1_;
+    TQ_UINT32 time2 = time2_;
+    if( time1 == time2 )
+        return 0;
+    return TQ_UINT32( time1 - time2 ) < 0x7fffffffU ? 1 : -1; // time1 > time2 -> 1, handle wrapping
+    }
+
+int NET::timestampDiff( unsigned long time1_, unsigned long time2_ ) // returns time2 - time1
+    { // no need to handle wrapping?
+    TQ_UINT32 time1 = time1_;
+    TQ_UINT32 time2 = time2_;
+    return TQ_UINT32( time2 - time1 );
+    }
+#endif
+
+
+#endif