Commit: e178dbf6dff37a8d287dd7d9bfc82c287b087bd0 - trjp_sawfish (git)

Japanese translation of message catalog for Sawfish Window-Manager

Commit MetaInfo

• Revision: e178dbf6dff37a8d287dd7d9bfc82c287b087bd0 (tree)
• Zeit: 2010-12-19 13:32:51
• Autor: Michal Maruska <mmaruska@gmai...>
• Commiter: Michal Maruska

Log Message

merge of mmc-stacking,mmc-debug into mmc-stacking-verbose

Conflicts:
src/windows.c

Ändern Zusammenfassung

• modified: src/Makefile.in
• add: src/debug-colors.h
• add: src/debug.h
• modified: src/display.c
• modified: src/events.c
• modified: src/frames.c
• modified: src/functions.c
• modified: src/images.c
• modified: src/keys.c
• modified: src/main.c
• add: src/mmc.c
• modified: src/pixmap-cache.c
• modified: src/property-cache.c
• modified: src/sawfish_subrs.h
• modified: src/stacking-list.c
• modified: src/windows.c
• modified: src/x.c

Diff

--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -28,7 +28,7 @@ VPATH=@srcdir@:@top_srcdir@
 
 SRCS :=	colors.c cursors.c display.c events.c fonts.c frames.c \
 	functions.c images.c keys.c main.c multihead.c pixmap-cache.c \
-	property-cache.c server.c session.c stacking-list.c windows.c
+	property-cache.c server.c session.c stacking-list.c windows.c mmc.c
 OBJS := $(SRCS:.c=.o)
 
 DL_SRCS := gradient.c flippers.c x.c selection.c

--- /dev/null
+++ b/src/debug-colors.h
@@ -0,0 +1,81 @@
+#ifndef DEBUG_COLORS_H
+#define DEBUG_COLORS_H
+
+
+#define color_green "\x1b[43;30m"  /* i have */
+
+/*was printf*/
+#define color_reset "\x1b[0m"
+/* requests: */
+#define unmap_request_color       "\x1b[48;5;209;38;5;232m"
+#define map_request_color       "\x1b[48;5;203;38;5;232m"
+
+#define flow_color "\x1b[31m"
+#define event_color             "\x1b[01;36m"
+#define serial_color  "\x1b[01;33m"
+#define events_color "\x1b[01;32;45m" /* how many events */
+/* #define event_color "\x1b[46;30m"  */
+#define event_name_color        "\x1b[01;45;37m"
+
+#define frame_color       "\x1b[48;5;177;38;5;232m"
+/* #define frame_color       "\x1b[38;5;119m" */
+
+#define move_color       "\x1b[38;5;119m"
+
+#define reparent_color       "\x1b[38;5;119m"
+
+/* for stacking! */
+#define functions_color   "\x1b[30;43m"
+#define message_color   "\x1b[33;1m"
+
+
+#define property_color   "\x1b[33;1m"
+#define time_color    "\x1b[33m"
+#define stacking_color   "\x1b[38;5;204m"
+
+#define window_color "\x1b[38;5;123m"
+#define frame_window_color  "\x1b[38;5;10m"
+#define image_color  "\x1b[48;5;177;38;5;159m" 
+
+
+/* fixme: I could simply output 2 Esc. sequences! */
+static
+inline char*
+color_fg_string(char* string, int part, char* buffer)
+{
+#define BUFFER_SIZE   20
+#if 0
+    static char buffer[BUFFER_SIZE];
+#endif
+
+#if 0
+    /* number_2_string ? */
+    strncat(buffer, BUFFER_SIZE, string, (toa part), );
+#else
+    snprintf(buffer, BUFFER_SIZE, "%s%dm", string, part);
+#endif
+    return buffer;
+}
+
+#define focus_mode_color "\x1b[01;37m"
+
+/* no! */
+#define focus_color   "\x1b[38;5;204m"
+#define another_focus_color "\x1b[31m"
+#define warning_color "\x1b[48;5;46;38;5;22m" 
+#define error_color "\x1b[01;37;41m"
+
+#define xkb_color       "\x1b[01;42;30m"
+#define keys_color "\x1b[01;36m"
+
+#define configure_color "\x1b[48;5;153m"
+
+/* events: */
+#define unmap_color       "\x1b[38;5;209m"
+#define map_color       "\x1b[38;5;203m"
+/*#define map_color       "\x1b[01;46;31m" */
+#define  grab_color    "\x1b[38;5;46m"
+#define  xgrab_color    "\x1b[01;33;41m"
+
+
+#endif /* DEBUG_COLORS_H */

--- /dev/null
+++ b/src/debug.h
@@ -0,0 +1,156 @@
+#ifndef DEBUG_H
+#define DEBUG_H
+
+#include "sawfish.h"
+
+/* format specifier */
+#define FMT_XID "lx" /* XID */
+#define FMT_WIN FMT_XID /* Window is unsigned long */
+
+
+#define DEBUG 1
+
+#define XAllowEvents_string "\x1b[01;33;41mXAllowEvents\x1b[0m"
+
+
+#define DB_EVENTS_FLOW 1   /* 1 */
+
+#define DB_EVENTS_MAP (1<<1)    /* 2 */
+#define DB_EVENTS_UNMAP (1<<2)  /* 4 */
+#define DB_EVENTS_FOCUS (1<<3)  /* 8 */               // 188 = 128 + 60 =    32 + 16 + 8 + 4        56 = 32 + 16 + 8
+
+/* 4+8 = 14   +16 = 30 */
+
+#define DB_EVENTS_TIME (1<<4)   /* 16 */
+
+#define DB_EVENTS_COLOR (1<<5)  /* 32 */
+#define DB_EVENTS_PROPERTY (1<<6)    /* 64 */
+#define DB_EVENTS_MISC (1<<7)/* 128                   216 = 128 + 64 +  16 8         -64  152  */
+#define DB_EVENTS_QUEUE (1<<8)  /* 256 */
+
+#define DB_EVENTS_QUEUE (1<<8)  /* 256 */
+
+#define DB_EVENTS_CONFIGURE (1 << 9)   /* 1 */
+/*  */
+
+#define DB_FUNCTIONS_GRAB (1<<1)
+#define DB_FUNCTIONS_REST (1<<7)
+#define DB_FUNCTIONS_MOUSE (1<<2)
+#define DB_FUNCTIONS_MOVE (1<<3)  /* 8*/
+
+#define DB_FUNCTIONS_MESSAGE (1<<4)  /* 16 */
+
+#define DB_FUNCTIONS_PROP (1<<5)  /* 32 */
+
+
+
+#define DB_WINDOWS_FOCUS 1
+
+#define DB_WINDOWS_PROT (1 << 1) /* protocol */
+#define DB_WINDOWS_ADD (1 << 2) /* 4 */
+#define DB_WINDOWS_FRAME (1 << 3) /* 8 */
+
+
+#define DB_WINDOWS_PUT (1 << 4) /* ??? */
+
+#define DB_WINDOWS_HOOKS (1<<6) /*  64 */
+#define DB_WINDOWS_REST (1<<7)  /* 128 */
+
+#define DB_WINDOWS_FIND (1<<8)
+#define DB_WINDOWS_GC (1<<9)
+
+#define DB_DISPLAY_ERROR 1
+
+
+#define DB_KEYS_INTER 4
+#define DB_KEYS_FLOW 128
+#define DB_KEYS_GRAB 2
+#define DB_KEYS_WINDOW 8
+#define DB_KEYS_WINDOW_DETAIL 16
+
+
+#define DB_FRAMES_FRAME (1 << 0) /* 2 */
+
+// ???
+#define DB_FRAMES_PARTS (1 << 1) /* 2 */
+
+
+#define DB_FRAMES_SHAPE (1 << 2) /* 4 */
+// #define DB_FRAMES_SHAPE (1 << 9) /* 512 */
+
+#define DB_FRAMES_PARTS_CONFIGURE (1 << 3) /* configure FPs to change their size/position */
+
+#define DB_FRAMES_BUILD (1 << 4) /*  16 */
+
+
+#define DB_FRAMES_ALLOC (1 << 5) /*  32 */
+#define DB_FRAMES_RE (1 << 6) /*  64   ... */
+
+#define DB_FRAMES_PARTS_BUILD (1 << 7) /* 128 */
+
+// fixme: should use `DB_FRAMES_RE'
+#define DB_FRAMES_PARTS_CHANGE (1 << 8) /* 256 */
+
+
+#define DB_FRAMES_DRAW (1 <<9)  /* 512 */
+
+
+
+
+#define DB_IMAGES_CREATE (1 << 1) 
+#define DB_IMAGES_RENDER (1 << 2) /* 4 */
+#define DB_IMAGES_OPS    (1 << 3) 
+#define DB_IMAGES_GET (1 << 4)
+#define DB_IMAGES_GC (1 << 5)
+
+
+
+#define DB_CACHE_DELETE (1 << 1)
+#define DB_CACHE_REF (1 << 2)
+#define DB_CACHE_MISS (1 << 3)  /* 8 */
+
+
+#define DB_STACKING_PROT (1 << 1) /* protocol */
+#define DB_STACKING_ALGO (1 << 2) /* 4 */
+#define DB_STACKING_WINDOWS_FRAME (1 << 3)
+
+
+
+/* frame options:
+ *  1          Frame bg black & pixmamp None!
+ *  2          atomic
+ *  4             pixbuf cache works as I want: 
+ *  8          DBE
+ *  16      ??
+ *  32         DO refresh_frame_parts  before Expose iff 1
+ *
+ *    43 =  32 + 11 = 8 + 3 = 2+1
+ *  64   ....  allow XConfigure on the FPs (which need it)
+
+ *  128    do not refresh on expose  a traced FP
+
+ *  256      make all gravity static
+ *  512   ... don't reconfigure FPs        .. rely on gravity!
+ *  1024  ... predict the reposition & maybe change the gravity?
+ *  2048  ... clearArea on each configure
+ */
+
+
+extern int debug_keys;
+extern int debug_stacking;
+extern int debug_events;
+extern int debug_functions;
+extern int debug_windows;
+extern int debug_frames;
+extern int debug_frame_part;
+extern int debug_images;
+extern int debug_cache;
+extern int debug_display;
+
+
+/* options */
+extern int default_grab_owner;
+extern int dont_allow_events;
+
+
+#endif /* DEBUG_H */

--- a/src/display.c
+++ b/src/display.c
@@ -31,6 +31,7 @@
 #include <stdarg.h>
 #include <ctype.h>
 
+#include <X11/Xproto.h>
 #ifdef HAVE_UNIX
 # ifdef HAVE_FCNTL_H
 #  include <fcntl.h>
@@ -50,6 +51,14 @@ int screen_num, screen_width, screen_height;
 Window root_window, no_focus_window;
 int shape_event_base, shape_error_base;
 
+int debug_display;
+/* A table of strings, probably in Xlib already? */
+#include "errors.h"
+#include "debug.h"
+#include "debug-colors.h"
+int debug_display = DB_DISPLAY_ERROR; /* a good default! */
+
+
 Visual *preferred_visual;
 int preferred_depth;
 
@@ -63,6 +72,39 @@ DEFSYM(canonical_display_name, "canonical-display-name");
 
 /* X error handlers */
 
+static const char*
+request_name (int request)
+{
+   request--;
+   /* return a string with the name,  or NULL */
+   if ((request >= 0) &&
+       (request < (sizeof(request_names)/sizeof(request_names[0]))))
+      return request_names[request];
+   else
+      return NULL;
+}
+
+static void
+print_error (XErrorEvent *ev)
+{
+    char buf[256];
+    const char* name = request_name(ev->request_code);
+
+    XGetErrorText(dpy, ev->error_code, buf, sizeof(buf));
+    fprintf(stderr, "X Error: %s\n", buf);
+
+    if (name)
+       fprintf(stderr, "The request was: %s, serial %lu\n", name, ev->serial);
+    else
+       fprintf(stderr, "The request was from some extension)!\n");
+
+    fprintf(stderr, "  Request Major code: %d\n", ev->request_code);
+    fprintf(stderr, "  Request Minor code: %d\n", ev->minor_code);
+    fprintf(stderr, "  ResourceId 0x%x (%d)\n", (unsigned int)ev->resourceid,
+            (unsigned int)ev->resourceid);
+                       /* i prefer to see both decimal and hexadecimal */
+}
+
 /* General error handler. Probably due to lag between windows being
    killed and us receiving DestroyNotify events */
 static int
@@ -70,6 +112,12 @@ error_handler (Display *dpy, XErrorEvent *ev)
 {
     Lisp_Window *w;
 
+    DB(("%s%s%s serial %u, XID %" FMT_XID ", type %d, %s\n", error_color, __FUNCTION__,
+        color_reset,
+        ev->serial, ev->resourceid, ev->type, request_name(ev->request_code)));
+    if (debug_display & DB_DISPLAY_ERROR)
+        print_error (ev);
+
     if (ev->resourceid != 0
 	&& (ev->error_code == BadWindow || ev->error_code == BadDrawable))
     {

--- a/src/events.c
+++ b/src/events.c
@@ -32,6 +32,10 @@
 #include <glib.h>
 #include <stdio.h>
 
+#include "debug.h"
+#include "debug-colors.h"
+int debug_events;
+
 /* Lookup table of event handlers */
 void (*event_handlers[LASTEvent])(XEvent *ev);
 
@@ -125,6 +129,8 @@ DEFSYM(normal, "normal");
 DEFSYM(grab, "grab");
 DEFSYM(ungrab, "ungrab");
 
+extern repv Qeval_key_release_events;
+
 repv Fsynthetic_configure_mutex (repv);
 
 /* `Time' will always be 32-bits, due to underlying wire protocol (?) */
@@ -309,6 +315,12 @@ colormap_notify (XEvent *ev)
 static void
 key_press (XEvent *ev)
 {
+    Lisp_Window *w = find_window_by_id (ev->xkey.window);
+    if (debug_keys & DB_KEYS_FLOW)
+        DB (("E: %s [%s %u @ %lu]-> eval_input_event (%s)\n", __FUNCTION__,
+             ev->type == KeyPress? "keyPress": "keyRelease",
+             ev->xkey.keycode, ev->xkey.time,
+             window_name (w)));
     record_mouse_position (ev->xkey.x_root, ev->xkey.y_root, ev->type, 0);
 
     /* Don't look for a context map, frame parts are never focused */
@@ -1446,6 +1458,133 @@ inner_handle_input (repv arg)
     return Qnil;
 }
 
+
+static void
+report_event (XEvent *xev)
+{
+#ifdef USE_XKB
+    /*  indeed!! */
+    if (debug_events)
+        report_xkb_event(xev);
+#endif
+    /* debugging + skipping Release */
+    switch (xev->type)
+    {
+        case KeyRelease:
+        case KeyPress:
+        {
+            char buf[256]; /* static ? */
+            u_long code, mods;
+
+            /* mmc: I prefer to see (the key combination pressed/release) here,
+             * se I run the lookup here:  */
+            if (!translate_event (&code, &mods, &xev))
+                break;         /*  why ??? */
+
+            lookup_event_name(buf, code, mods);
+
+
+            char* name = "unknown window";
+            /* do i need to protect it from GC? */
+            Lisp_Window* kw = find_window_by_id(xev->xkey.window);
+            if (kw)
+                name = (char *) rep_STR (kw->name);
+            else if (xev->xkey.window == no_focus_window)
+                name = "no_focus_window";
+            else if (xev->xkey.window == root_window)
+                name = (xev->xkey.subwindow == no_focus_window ) ?
+                    "no_focus_window via root_window" : "root_window";
+
+            // xev->xkey.subwindow
+            if (debug_keys)  /*  & DB_EVENTS_TIME */
+                DB (("** Key: serial:%s%d%s %s %s time: %u %s%s%s/%d %d\n",
+                     keys_color ,xev->xkey.serial, color_reset,
+                     xev->type < LASTEvent ?event_names[xev->type]:"unknown event",
+                     buf,
+                     xev->xkey.time, /*my_timestamp(xev->xkey.time),*/
+                     name,
+
+                     (kw && (kw->id == xev->xkey.window)) ? "window (grab?)" :
+                     ((kw && (kw->frame == xev->xkey.window)) ? "frame" : ""),
+
+                     (xev->xkey.subwindow == xev->xkey.window) ? "" : "->subwindow"
+                     ,xev->xkey.window, xev->xkey.subwindow
+                     /*xev->xkey.time*/
+                     ));
+            if (xev->type==KeyRelease
+                && (global_symbol_value (Qeval_key_release_events) == Qnil));
+            /* why ?? ... so assert? */
+            break;
+        }
+        default:
+            if (! ((xev->type == Expose)
+                   // ||  (xev->type == PropertyNotify)
+                   ||  (xev->type == VisibilityNotify)
+
+                   /* if i set DB_EVENTS_MISC -> i want to see even those */
+                   || (!(debug_events & DB_EVENTS_MISC)
+                       &&
+                       (((xev->type == UnmapNotify)
+                         || (xev->type == ConfigureNotify)
+                         || (xev->type == MapNotify))
+                        && (xev->xany.window == root_window)))
+                   /* 64 root_window ... this means, that the event is reported to the root.*/
+                   ))
+            {
+                /* do */
+                if (debug_events & DB_EVENTS_FLOW)
+                {
+                    /* i'm not interested that the event arrived via root_window !! */
+                    Window id = xev->xany.window;
+                    Window event = xev->xany.window;
+
+                    switch (xev->type){
+                        case UnmapNotify:
+                            id = xev->xunmap.window;
+                            break;
+                        case MapNotify:
+                            id = xev->xmap.window;
+                            break;
+                        case ConfigureNotify:
+                            id = xev->xconfigure.window;
+                            break;
+                        case ConfigureRequest:
+                            id = xev->xconfigurerequest.window;
+                            break;
+                            /* Garbagge collection !!!! am i losing prompt b/c of that? */
+                        case CreateNotify: /*  */
+                            id = xev->xcreatewindow.window;
+                            break;
+                        case DestroyNotify:
+                            id = xev->xdestroywindow.window;
+                            /* premature here? */
+                            break;
+                        case MapRequest:
+                            id = xev->xmaprequest.window;
+                            break;
+                        default:
+                            id = xev->xany.window;
+                    };
+                    Lisp_Window *w = find_window_by_id (id)? : find_window_by_frame(id);
+
+                    DB (("** Event: serial:%s%d%s: %s%s%s (event: %x win %x: %s)\n",
+                         event_color, xev->xkey.serial, color_reset,
+                         event_name_color,
+                         xev->type < LASTEvent ? event_names[xev->type] : "unknown", color_reset,
+                         event, id,
+                         (w) ? rep_STR (w->name) : (u_char *)"unknown"));
+                }
+            } else {
+                /* give a small hint at the quantity.*/
+                DB(("%s%s%s", events_color,
+                    (xev->xany.window == no_focus_window) ? "F":
+                    (xev->xany.window == root_window) ? "R": "@", color_reset
+                    )); /* @ */
+            }
+    };
+
+}
+
 /* Handle all available X events matching event mask MASK. Or any events
    if MASK is zero. */
 void
@@ -1488,15 +1627,7 @@ handle_input_mask(long mask)
 	if (xev.type == NoExpose || xev.type == GraphicsExpose)
 	    continue;
 
-#ifdef DEBUG
-	do {
-	    Lisp_Window *w = x_find_window_by_id (xev.xany.window);
-	    DB(("** Event: %s (win %lx: %s)\n",
-		xev.type < LASTEvent ? event_names[xev.type] : "unknown",
-		(long)xev.xany.window, w ? (char *) rep_STR (w->name) : "unknown"));
-	} while (0);
-#endif
-
+        report_event (&xev);
 	record_event_time (&xev);
 	current_x_event = &xev;
 	invalidate_cached_mouse_position ();

--- a/src/frames.c
+++ b/src/frames.c
@@ -43,6 +43,10 @@
 #include <X11/Xresource.h>
 #include <X11/extensions/shape.h>
 #include <assert.h>
+#include "debug.h"
+#include "debug-colors.h"
+int debug_frames;
+
 
 static XID window_fp_context;
 
@@ -1386,6 +1390,7 @@ build_frame_part (struct frame_part *fp)
     else
 	fp->rendered_image = Qnil;
 
+    if (debug_frames)
     DB(("  part: x=%d y=%d width=%d height=%d\n",
 	fp->x, fp->y, fp->width, fp->height));
 
@@ -1502,6 +1507,7 @@ list_frame_generator (Lisp_Window *w)
     else
 	right_x = bottom_y = 0;
 
+    if (debug_frames)
     DB(("list_frame_generator(%s)\n", rep_STR(w->name)));
 
     while (gen_list != Qnil && rep_SYMBOLP(gen_list) && !rep_INTERRUPTP)
@@ -1585,6 +1591,7 @@ list_frame_generator (Lisp_Window *w)
     w->frame_x = left_x;
     w->frame_y = top_y;
 
+    if (debug_frames)
     DB(("  bounding box: x=%d y=%d width=%d height=%d\n",
 	left_x, top_y, w->frame_width, w->frame_height));
 
@@ -1729,6 +1736,7 @@ restack_frame_parts (Lisp_Window *w)
 void
 create_window_frame (Lisp_Window *w)
 {
+    if (debug_frames)        
     DB(("create_window_frame (%s)\n", rep_STR(w->name)));
     if (w->frame_parts == 0)
     {

--- a/src/functions.c
+++ b/src/functions.c
@@ -45,6 +45,10 @@
 #include <X11/Xatom.h>
 #include <stdint.h>
 
+#include "debug.h"
+#include "debug-colors.h"
+int debug_functions=0;
+
 /* Number of outstanding server grabs made; only when this is zero is
    the server ungrabbed. */
 static int server_grabs;
@@ -124,12 +128,14 @@ windows isn't affected.
     repv ptr;
     Lisp_Window *pred;
 
+    /* check that it's a list of _windows_ */
     rep_DECLARE1(list, rep_LISTP);
     for (ptr = list; rep_CONSP (ptr); ptr = rep_CDR (ptr))
     {
 	if (!WINDOWP (rep_CAR (ptr)))
 	    return rep_signal_arg_error (list, 1);
     }
+    /* end of the check*/
 
     if (list == Qnil)
 	return Qt;
@@ -137,6 +143,8 @@ windows isn't affected.
     ptr = list;
     pred = 0;
 
+    if (debug_stacking)
+        DB (("%s%s%s\n", functions_color, __FUNCTION__, color_reset));
     while (rep_CONSP (ptr))
     {
 	Lisp_Window *this = VWIN (rep_CAR (ptr));

--- a/src/images.c
+++ b/src/images.c
@@ -50,6 +50,10 @@ static ImlibData *imlib_id;
 GdkInterpType interp_type = GDK_INTERP_BILINEAR;
 #endif
 
+#include "debug.h"
+#include "debug-colors.h"
+int debug_images = 0;
+
 Colormap image_cmap;
 Visual *image_visual;
 int image_depth;

--- a/src/keys.c
+++ b/src/keys.c
@@ -27,6 +27,10 @@
 #include <X11/keysym.h>
 #include <X11/Xutil.h>
 
+#include "debug.h"
+#include "debug-colors.h"
+int debug_keys;
+
 /* max number of milliseconds between successive-clicks */
 #define DEFAULT_DOUBLE_CLICK_TIME 250
 

--- a/src/main.c
+++ b/src/main.c
@@ -500,6 +500,7 @@ where OPTIONS are any of:\n\
 	    Fset (Qfonts_are_fontsets, Qnil);
 	}
 
+        set_init ();
 	/* call all init funcs... */
 	session_init ();
 	events_init ();

--- /dev/null
+++ b/src/mmc.c
@@ -0,0 +1,608 @@
+#include "sawfish.h"
+#include <sys/resource.h>
+#include <time.h>
+
+/* fixme: this assumes a 255-color xterm! */
+
+#ifdef USE_XKB
+#include <X11/XKBlib.h>         /* extensions/XKB.h */
+#include <X11/extensions/XKBstr.h>
+extern int usexkb;
+#endif  /* USE_XKB */
+
+#include <errno.h>
+#include <assert.h>
+
+#include "debug.h"
+#include "debug-colors.h"
+
+
+const char*
+window_name (Lisp_Window *w)
+{
+    /* todo:  root_window or no_focus_window ? */
+    repv name = (w)?(w->net_name != Qnil ? w->net_name : w->name) : NULL;
+    /* stolen from window-name */
+    return (name ? (char *) rep_STR(name) : (w?"unknown":"NULL"));
+}
+
+const char*
+window_name_id (Lisp_Window *w, Window id)
+{
+    if (w)
+        return window_name(w);
+    else 
+        return ((id == no_focus_window) ? "no_focus_window"
+                : ((id == root_window) ? "Root_window" : "unknown"));
+}
+
+/* mmc: make a nice string format from the Time T
+ * only for debugging
+ */
+
+char*
+my_timestamp(Time t)
+{
+    static char buf[30];	/*  like asctime */
+
+    /* fixme:  non standard ?? */
+    int sec= (int) t / 1000;
+    int min= (int) sec / 60;
+    int rest=(int) min / 60;
+
+    min= min % 60;
+    sec= sec % 60;
+    
+                                
+    
+    sprintf(buf, "%s%u:%2u:%02u:%02lu%s",
+            time_color,
+            rest,
+            min,
+            sec,
+            t % 1000,             /* (t /10 ) */
+            color_reset);
+    return buf;
+}
+
+/* a useless confirmation? */
+bool
+window_is_frame_part (Window id, Lisp_Window *w)
+{
+   struct frame_part* p = w->frame_parts;
+   while (p != NULL)
+      {
+         if (p->id == id)
+            return TRUE;
+         p = p->next;
+      }
+   return FALSE;
+}
+
+Lisp_Window *
+find_window_by_frame (Window id)
+{
+   Lisp_Window *w;
+
+   w = window_list;
+   while (w != 0 && w->frame != id)
+      w = w->next;
+   return w;
+}
+
+
+inline char*
+window_relation_desc (Lisp_Window *w, Window id)
+{
+    return ((id == w->id)? "(" window_color "itself" color_reset ")" :
+            ( (id == w->frame) ? "(" frame_window_color "frame" color_reset")" :
+              (window_is_frame_part (id, w) ? "frame_part" : "??" )));
+}
+
+
+static char* focus_detail_names[]=
+{
+   "NotifyAncestor",
+   "NotifyVirtual",
+   "NotifyInferior",                                                 
+   "NotifyNonlinear",
+   "NotifyNonlinearVirtual",
+   "NotifyPointer",                                         
+   "NotifyPointerRoot",
+   "NotifyDetailNone"
+};
+
+
+char* focus_mode_string[] =
+{
+   /* taken from /usr/include/X11/X.h */
+   "NotifyNormal",
+   "NotifyGrab",
+   "NotifyUngrab",
+   "NotifyWhileGrabbed",
+};
+
+char* buffer;
+
+#define color_fg(string, fg) (buffer = alloca(BUFFER_SIZE),            \
+                              color_fg_string(string, fg, buffer))
+
+void
+describe_focus_in(XEvent *ev,Lisp_Window *w)
+{
+   assert (ev->xfocus.detail < 8); /* what is 8? */
+
+   int color= ((ev->xfocus.mode) == NotifyGrab)?145:
+      (((ev->xfocus.mode) == NotifyUngrab)?146:147);
+         
+   DB (("%s%s received %lu win = %" FMT_WIN ":%s(%s) mode: %s%s%s detail: %s%s%s\n",
+        color_fg("\x1b[38;5;",color),
+        /* "%s received %d win = %s mode: %s detail:\n", */
+        //(ev->xfocus.type == FocusIn)? "focus_in": "focus_out",
+        __FUNCTION__,
+
+        ev->xfocus.serial,
+        w->id,
+        window_name_id (w, ev->xfocus.window),
+        (w) ? window_relation_desc (w,ev->xfocus.window):"",
+
+        color_fg("\x1b[38;5;", 116+ev->xfocus.mode),
+        (ev->xfocus.mode < sizeof(focus_mode_string)/sizeof(focus_mode_string[0])) ?
+        focus_mode_string[ev->xfocus.mode]:"<unexpected>!",
+        color_reset,
+              
+        color_fg("\x1b[38;5;", color),
+        /* focus_mode_color, */
+        /* ev->xfocus.detail, */
+        focus_detail_names[ev->xfocus.detail],
+        color_reset)); 
+}
+
+/*static */
+void
+describe_focus_out(XEvent *ev, Lisp_Window *w)
+{
+    if (!(ev->xfocus.detail < (sizeof(focus_detail_names) /sizeof(focus_detail_names[0]))))
+        return;
+   
+    if (!w)
+        w = find_window_by_frame (ev->xfocus.window);
+   
+    char* window_name = window_name_id (w,ev->xfocus.window);
+    int color= ((ev->xfocus.mode) == NotifyGrab)? 36:
+        (((ev->xfocus.mode) == NotifyUngrab)?34:33);
+
+    DB (("%s%s%s serial %lu win = %" FMT_WIN " %s(%s) mode: %s%s%s detail: %s%s%s\n", /* %d */
+         /* "%s received %d win = %s mode: %s detail:\n", */
+         color_fg("\x1b[38;5;",color),
+         __FUNCTION__,  // (ev->xfocus.type == FocusIn)? "focus_in": "focus_out",
+         color_reset,
+         ev->xfocus.serial,
+         ev->xfocus.window,
+         window_name,
+         (w) ? window_relation_desc (w,ev->xfocus.window):"",
+               
+         color_fg("\x1b[38;5;", 116 + ev->xfocus.mode),
+         ((ev->xfocus.mode < sizeof(focus_mode_string)/sizeof(focus_mode_string[0]))?
+          focus_mode_string[ev->xfocus.mode]:"<unexpected>!"),
+         color_reset,
+
+         /* detail: */
+         color_fg("\x1b[38;5;", color),
+         focus_detail_names[ev->xfocus.detail],              /* ev->xfocus.detail, */
+         color_reset));
+};
+
+extern int restack_fast;
+int
+set_int_variable(int* var, repv value)
+{
+   rep_DECLARE1 (value, rep_INTP);
+
+   int old=*var;
+   *var = rep_INT(value);
+   return rep_MAKE_INT(old);
+}
+
+
+/* mmc: i should add  incrementing/decrementing &  commit-on-zero? */
+DEFUN("set-restack-fast", Fset_restack_fast, Sset_restack_fast, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-restack-fast
+make the following restacking operations immediate if 0, and posponed if 1
+::end:: */
+{
+   rep_DECLARE1 (debug, rep_INTP);
+   return set_int_variable(&restack_fast, debug);
+}
+
+extern bool be_proactive_in_move;
+
+
+#if 0
+DEFUN("set-proactive-move", Fset_proactive_move, Sset_proactive_move, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events#set-proactive-move::
+set-proactive-move 0/1
+::end:: */
+{
+    rep_DECLARE1 (debug, rep_INTP);
+    return set_int_variable(&be_proactive_in_move, debug);
+}
+#endif
+
+
+DEFUN("set-debug-events", Fset_debug_events, Sset_debug_events, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events#set-debug-events::
+set-debug-events 0/1
+::end:: */
+{
+    rep_DECLARE1 (debug, rep_INTP);
+    return set_int_variable(&debug_events, debug);
+}
+
+DEFUN("set-debug-windows", Fset_debug_windows, Sset_debug_windows, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.windows#set-debug-windows::
+set-debug-windows 0/1
+::end:: */
+{
+    rep_DECLARE1 (debug, rep_INTP);
+    return set_int_variable(&debug_windows, debug);
+}
+
+
+DEFUN("set-debug-keys", Fset_debug_keys, Sset_debug_keys, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-debug-keys
+set-debug-keys 0/1
+::end:: */
+{
+    rep_DECLARE1 (debug, rep_INTP);
+    return set_int_variable(&debug_keys, debug);
+}
+
+DEFUN("set-debug-stacking", Fset_debug_stacking, Sset_debug_stacking, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-debug-keys
+set-debug-keys 0/1
+::end:: */
+{
+    rep_DECLARE1 (debug, rep_INTP);
+    return set_int_variable(&debug_stacking, debug);
+}
+
+
+#ifdef USE_XKB
+/* work-in-progress? */
+DEFUN("set-xkb-event-mask", Fset_xkb_event_mask, Sset_xkb_event_mask, (repv mask, repv value), rep_Subr2) /*
+::doc:sawfish.wm.events::set-debug-keys
+set-debug-keys 0/1
+::end:: */
+{
+   rep_DECLARE1 (mask, rep_INTP);
+   rep_DECLARE2 (value, rep_INTP);
+
+   if (usexkb)
+    /* i want to report them. */
+      XkbSelectEvents(dpy, XkbUseCoreKbd, rep_INT(mask), rep_INT(value)); /* `set' */
+/*   XkbSelectEventsDetails(dpy, XkbUseCoreKbd, XkbMapNotifyMask, XkbMapNotifyMask);  `set' */
+/*    return set_int_variable(&xallowevents_handling, debug); */
+    return Qnil;
+}
+
+
+#endif
+
+
+
+DEFUN("set-debug-functions", Fset_debug_functions, Sset_debug_functions, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-debug-functions
+set-debug-functions 0/1
+::end:: */
+{
+   rep_DECLARE1 (debug, rep_INTP);
+   return set_int_variable(&debug_functions, debug);
+}
+
+
+DEFUN("set-debug-display", Fset_debug_display, Sset_debug_display, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-debug-display
+set-debug-display 0/1
+::end:: */
+{
+    rep_DECLARE1 (debug, rep_INTP);
+    return set_int_variable(&debug_display, debug);
+}
+
+
+DEFUN("set-debug-images", Fset_debug_images, Sset_debug_images, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-debug-images
+set-debug-images 0/1
+::end:: */
+{
+    rep_DECLARE1 (debug, rep_INTP);
+    return set_int_variable(&debug_images, debug);
+}
+
+DEFUN("set-debug-cache", Fset_debug_cache, Sset_debug_cache, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-debug-cache
+set-debug-cache 0/1
+::end:: */
+{
+    rep_DECLARE1 (debug, rep_INTP);
+    return set_int_variable(&debug_cache, debug);
+}
+
+#if 0
+DEFUN("set-grab-owner", Fset_grab_owner, Sset_grab_owner, (repv owner), rep_Subr1) /*
+::doc:sawfish.wm.events::set-debug-display
+set-debug-display 0/1
+::end:: */
+{
+    rep_DECLARE1 (owner, rep_INTP); /* fixme: should be boolean! */
+    return set_int_variable(&default_grab_owner, owner);
+}
+#endif
+
+DEFUN("next-request", Fnext_request, Snext_request, (void), rep_Subr0) /*
+::doc:sawfish.wm.events::next-request
+next-request 
+::end:: */
+{
+   return rep_MAKE_INT(NextRequest(dpy));
+}
+
+DEFUN("set-debug-frames", Fset_debug_frames, Sset_debug_frames, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-debug-frames
+set-debug-frames 0/1
+::end:: */
+{
+   rep_DECLARE1 (debug, rep_INTP);
+   return set_int_variable(&debug_frames, debug);
+}
+
+#if 0
+DEFUN("set-debug-frame-part", Fset_debug_frame_part, Sset_debug_frame_part, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-debug-frames
+set-debug-frames 0/1
+::end:: */
+{
+   rep_DECLARE1 (debug, rep_INTP);
+   return set_int_variable(&debug_frame_part, debug);
+}
+
+
+DEFUN("set-dont-allow-events", Fset_dont_allow_events, Sset_dont_allow_events, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-dont-allow-event
+::set-dont-allow-event 0/1
+::end:: */
+{
+    rep_DECLARE1 (debug, rep_INTP);
+    DB(("set-dont-allow-events %d -> %d (now)\n", dont_allow_events, rep_INT(debug)));
+    return set_int_variable(&dont_allow_events, debug);
+}
+#endif
+
+int frame_options;
+
+DEFUN("set-frame-options", Fset_frame_options, Sset_frame_options, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-frame-options
+set-frame-options 0/1
+::end:: */
+{
+   rep_DECLARE1 (debug, rep_INTP);
+   return set_int_variable(&frame_options, debug);
+}
+
+
+
+int window_options;
+
+DEFUN("set-window-options", Fset_window_options, Sset_window_options, (repv debug), rep_Subr1) /*
+::doc:sawfish.wm.events::set-frame-options
+set-frame-options 0/1
+::end:: */
+{
+   rep_DECLARE1 (debug, rep_INTP);
+   return set_int_variable(&window_options, debug);
+}
+
+
+
+
+/* Run external program w/ UID  (su)
+ * set & get priority.
+ * */
+
+DEFUN("get-priority", Fget_priority, Sget_priority, (repv which, repv who), rep_Subr2) /*
+::doc:sawfish.wm.events::set-debug-display
+(get-priority 0 0)  to get the  sawfish WM process's priority.
+::end:: */
+{
+   rep_DECLARE1(which, rep_INTP);
+   rep_DECLARE2(who, rep_INTP);
+
+#if 0
+enum __priority_which
+{
+  PRIO_PROCESS = 0,		/* WHO is a process ID.  */
+#define PRIO_PROCESS PRIO_PROCESS
+  PRIO_PGRP = 1,		/* WHO is a process group ID.  */
+#define PRIO_PGRP PRIO_PGRP
+  PRIO_USER = 2			/* WHO is a user ID.  */
+#define PRIO_USER PRIO_USER
+};
+#endif
+
+
+
+   int c_which = rep_INT(which);
+   if ((c_which == PRIO_PROCESS)
+       || (c_which == PRIO_PGRP)
+       || (c_which == PRIO_USER))
+       {
+           /*  Since  getpriority()  can  legitimately return the value -1, it is necessary to clear the
+               external variable errno prior to the call */
+           errno = 0;
+           int res = getpriority(c_which, rep_INT(who));
+
+           if ((res == -1) && errno)
+               {
+                   /* throw error! */
+                   return rep_FALSE;
+                   /* rep_handle_error */
+                   return rep_signal_arg_error(which, 0);
+               }
+           else
+               {
+                   return rep_MAKE_INT(res);
+               }
+       }
+   else return rep_signal_arg_error(which, 0);
+}
+
+
+
+
+static repv
+reopen_stdio_stream(FILE** pointer, char* filename)
+{
+   /* can access? */
+   /* FILE* */
+   FILE* result = freopen(filename, "a", *pointer);
+   if (result){
+      
+      /* setlinebuf(result); */
+      setvbuf(result, (char *)NULL, _IONBF, 0);
+   } else
+      {
+         /*disaster!!! */
+         XBell(dpy,0);
+         result = freopen("/dev/null", "a", *pointer);
+      };
+   assert(result);
+
+   *pointer = result;
+   DB(("%s: %s %d\n", __FUNCTION__, result?"ok":"error!", result?fileno(result):-1));
+   return result?rep_TRUE:rep_FALSE;
+}
+
+
+
+
+
+
+DEFUN("reopen-stderr", Freopen_stderr, Sreopen_stderr, (repv filename), rep_Subr1) /*
+::doc:sawfish.wm.events::reopen-stderr
+redirect-stderr-to filename
+::end:: */
+{
+   rep_DECLARE1(filename, rep_STRINGP);
+
+   FILE **stdio_stream = &stderr;
+   
+   repv result = reopen_stdio_stream (&stderr, rep_STR(filename));
+   
+   repv stream = Fstderr_file();
+   rep_FILE(stream)->file.fh = *stdio_stream;
+   return result?rep_TRUE:rep_FALSE;
+}
+
+
+DEFUN("reopen-stdout", Freopen_stdout, Sreopen_stdout, (repv filename), rep_Subr1) /*
+::doc:sawfish.wm.events::reopen-stdout
+redirect-stdout-to filename
+::end:: */
+{
+   rep_DECLARE1(filename, rep_STRINGP);
+
+   FILE **stdio_stream = &stdout;
+   repv result = reopen_stdio_stream (stdio_stream, rep_STR(filename));
+   
+   repv stream = Fstdout_file();
+   rep_FILE(stream)->file.fh = *stdio_stream;
+   return result?rep_TRUE:rep_FALSE;
+}
+
+
+
+#if 0
+bool
+reopen_lisp_stream(repv stream, char* filename)
+{
+   /* assert (stream_p()) */
+   FILE **stdio_stream = &(rep_FILE(stream)->file.fh); /* ??? */
+   /* if (*strio_stream) */
+   repv result = reopen_stdio_stream (stdio_stream, rep_STR(filename));
+   rep_FILE(stream)->file.fh = *stdio_stream;
+}
+
+
+
+reopen_lisp_stream(Fstdout_file());
+#endif
+
+static int
+get_int_variable_from_env(char* name, int* variable)
+{
+   if (getenv(name) != NULL)
+      {
+         *variable = atoi(getenv(name));
+         DB(("using the ENV VAR $%s = %s -> %d\n", name, getenv(name), *variable));
+         return *variable;
+      }
+   return 0;
+}
+
+
+void
+set_init (void)
+{
+    repv tem;
+
+    tem = rep_push_structure ("sawfish.wm.windows.subrs");
+
+
+    /* rep_ADD_SUBR(Sstart_restacking); */
+    rep_ADD_SUBR(Sreopen_stderr);
+    rep_ADD_SUBR(Sreopen_stdout);
+
+    rep_ADD_SUBR(Sget_priority);
+    rep_ADD_SUBR(Sset_restack_fast);
+
+    rep_ADD_SUBR(Sset_debug_functions);
+    rep_ADD_SUBR(Sset_debug_display);
+    rep_ADD_SUBR(Sset_debug_images);
+    rep_ADD_SUBR(Sset_debug_cache);
+
+    rep_ADD_SUBR(Snext_request);
+    rep_pop_structure (tem);
+
+    tem = rep_push_structure ("sawfish.wm.events");
+#if 0
+    rep_ADD_SUBR(Sset_grab_owner);
+    rep_ADD_SUBR(Sset_dont_allow_events);
+    rep_ADD_SUBR(Sset_debug_frame_part);
+    rep_ADD_SUBR(Sset_frame_options);
+    rep_ADD_SUBR(Sset_window_options);
+    rep_ADD_SUBR(Sset_xkb_event_mask);
+    rep_ADD_SUBR(Sset_proactive_move);
+
+    rep_INTERN_SPECIAL(debug_events);
+    Fset (Qdebug_events, rep_MAKE_INT(0));
+    rep_ADD_SUBR(Sset_xallowevents_handling);
+#endif
+    rep_ADD_SUBR(Sset_debug_events);
+    rep_ADD_SUBR(Sset_debug_windows);
+    rep_ADD_SUBR(Sset_debug_keys);
+    rep_ADD_SUBR(Sset_debug_stacking);
+
+    rep_ADD_SUBR(Sset_debug_frames);
+
+    rep_pop_structure (tem);
+
+    /* initial debug. */
+    get_int_variable_from_env("SAWFISH_DEBUG_STACKING", &debug_stacking);
+    get_int_variable_from_env("SAWFISH_DEBUG_WINDOWS", &debug_windows);
+    get_int_variable_from_env("SAWFISH_DEBUG_FUNCTIONS", &debug_functions);
+
+    get_int_variable_from_env("SAWFISH_DEBUG_EVENTS", &debug_events);
+    get_int_variable_from_env("SAWFISH_DEBUG_KEYS", &debug_keys);
+    get_int_variable_from_env("SAWFISH_DEBUG_FRAMES", &debug_frames);
+}

--- a/src/pixmap-cache.c
+++ b/src/pixmap-cache.c
@@ -42,6 +42,10 @@
 static unsigned long cached_pixels, max_cached_pixels = 64 * 1024;
 static unsigned long hits, misses;
 
+#include "debug.h"
+#include "debug-colors.h"
+int debug_cache;
+
 #ifdef NEED_PIXMAP_CACHE
 
 struct pixmap_cache_node_struct {
@@ -144,12 +148,16 @@ pixmap_cache_ref (Lisp_Image *im, int width, int height,
 	    remove_from_age_list (n);
 	    prepend_to_age_list (n);
 	    n->ref_count++;
+            if (debug_cache & DB_CACHE_REF)
+               DB(("%s now: %d\n", __FUNCTION__, n->ref_count)); 
 	    *p1 = n->p1;
 	    *p2 = n->p2;
 	    hits++;
 	    return TRUE;
 	}
     }
+    if (debug_cache & DB_CACHE_MISS)
+       DB(("%s missed!\n", __FUNCTION__));
     misses++;
     return FALSE;
 }
@@ -163,6 +171,8 @@ pixmap_cache_unref (Lisp_Image *im, Pixmap p1, Pixmap p2)
 	if (n->p1 == p1 && n->p2 == p2)
 	{
 	    n->ref_count--;
+            if (debug_cache & DB_CACHE_REF)
+               DB(("%s remain %d\n", __FUNCTION__, n->ref_count));
 #ifdef DISABLE_CACHE
 	    if (n->ref_count == 0)
 		delete_node (n, TRUE);
@@ -170,6 +180,8 @@ pixmap_cache_unref (Lisp_Image *im, Pixmap p1, Pixmap p2)
 	    return;
 	}
     }
+    if (debug_cache)
+       DB(("%s\n", __FUNCTION__));
     fprintf (stderr, "warning: unref'ing unknown image in pixmap-cache\n");
 }
 
@@ -179,7 +191,9 @@ pixmap_cache_set (Lisp_Image *im, int width, int height,
 {
     int pixel_count = width * height;
     pixmap_cache_node *n = 0;
+    int deleted = 0;
 
+    /* shring the cache: */
     while (pixel_count + cached_pixels > max_cached_pixels)
     {
 	/* remove oldest node */
@@ -189,9 +203,12 @@ pixmap_cache_set (Lisp_Image *im, int width, int height,
 	if (this == 0)
 	    break;
 	delete_node (this, n != 0);
+        ++deleted;
 	if (n == 0)
 	    n = this;
     }
+    if (debug_cache & DB_CACHE_DELETE)
+       DB(("%s had to delete %d nodes.\n", __FUNCTION__, deleted));
 
     if (n == 0)
 	n = rep_alloc (sizeof (pixmap_cache_node));
@@ -212,6 +229,8 @@ void
 pixmap_cache_flush_image (Lisp_Image *im)
 {
     pixmap_cache_node *n, *next;
+    if (debug_cache)
+        DB(("%s %p\n", __FUNCTION__, im));
     for (n = im->pixmap_first; n != 0; n = next)
     {
 	next = n->next;

--- a/src/property-cache.c
+++ b/src/property-cache.c
@@ -50,20 +50,16 @@ property_cache_ref (repv id, repv prop)
 
     h = CACHE_HASH (id, prop) * CACHE_ASSOC;
 
-    DB (("prop ref: 0x%x,%s (%d) -> ", id, rep_STR (rep_SYM (prop)->name), h));
-
     for (i = h; i < h + CACHE_ASSOC; i++)
     {
 	if (cache_ids[i] == id && cache_props[i] == prop)
 	{
 	    cache_hits++;
-	    DB (("hit\n"));
 	    cache_ages[i] = ++cache_clock;
 	    return cache_values[i];
 	}
     }
 
-    DB (("miss\n"));
     cache_misses++;
     return rep_NULL;
 }
@@ -106,16 +102,11 @@ property_cache_set (repv id, repv prop, repv value, int invals)
 
     assert (oldest != -1);
 
-    if (cache_ids[oldest] != 0)
-	DB (("prop eject: 0x%x (%d)\n", cache_ids[oldest], oldest));
-
     cache_ids[oldest] = id;
     cache_props[oldest] = prop;
     cache_values[oldest] = value;
     cache_ages[oldest] = ++cache_clock;
     cache_updates[oldest] = invals;
-
-    DB (("set: 0x%x,%s (%d)\n", id, rep_STR (rep_SYM (prop)->name), oldest));
 }
 
 void

--- a/src/sawfish_subrs.h
+++ b/src/sawfish_subrs.h
@@ -58,6 +58,7 @@ extern Window root_window, no_focus_window;
 extern Atom xa_wm_state, xa_wm_change_state, xa_wm_protocols,
     xa_wm_delete_window, xa_wm_colormap_windows, xa_wm_take_focus,
   xa_compound_text, xa_wm_net_name, xa_wm_net_icon_name, xa_utf8_string;
+extern Atom ignore_atoms[2];    /* _WIN_AREA  _WIN_WORKSPACE */
 extern int shape_event_base, shape_error_base;
 extern repv Qdisplay_name, Qcanonical_display_name;
 extern bool sys_init (char *program_name);
@@ -368,4 +369,14 @@ extern void restack_window (Lisp_Window *w);
 extern repv make_stacking_list (void);
 extern void push_stacking_list_to_server(Lisp_Window**, int len);
 
+/* from mmc.c */
+extern const char* window_name (Lisp_Window *w);
+extern const char* window_name_id (Lisp_Window *w, Window id);
+extern char* my_timestamp(Time t);
+extern void describe_focus_out(XEvent *ev, Lisp_Window *w);
+extern void describe_focus_in(XEvent *ev,Lisp_Window *w);
+
+extern void set_init (void);
+
+
 #endif /* SAWFISH_SUBRS_H */

--- a/src/stacking-list.c
+++ b/src/stacking-list.c
@@ -24,6 +24,10 @@
 
 #include "sawfish.h"
 #include <assert.h>
+#include "debug.h"
+#include "debug-colors.h"
+int debug_stacking;
+
 
 static Lisp_Window *lowest_window, *highest_window;
 static int stacking_list_length ();

--- a/src/windows.c
+++ b/src/windows.c
@@ -26,7 +26,12 @@
 #include <glib.h>
 
 
+#include "debug.h"
+#include "debug-colors.h"
+int debug_windows;
 extern int restack_fast;
+
+
 Lisp_Window *window_list;
 int window_type;
 
@@ -101,6 +106,10 @@ mapped_not_override_p (Window id)
     XWindowAttributes wa;
 
     XGetWindowAttributes(dpy, id, &wa);
+    if (debug_windows & DB_WINDOWS_REST)
+       DB (("%s %" FMT_WIN " %s %s\n", __FUNCTION__, id,
+            (wa.map_state == IsUnmapped)?"is unmapped!":"",
+            (wa.override_redirect == True)?"has override!":""));
     return ((wa.map_state != IsUnmapped) && (wa.override_redirect != True));
 }
 
@@ -145,7 +154,7 @@ commit_queued_focus_change (void)
     {
 	if (queued_take_focus)
 	{
-	    DB(("  sending WM_TAKE_FOCUS %x %ld\n",
+	    DB(("  sending WM_TAKE_FOCUS %" FMT_WIN " %ld\n",
 		(unsigned) queued_focus_id, queued_focus_time));
 	    send_client_message (queued_focus_id,
 				 xa_wm_take_focus,
@@ -153,7 +162,7 @@ commit_queued_focus_change (void)
 	}
 	if (queued_set_focus)
 	{
-	    DB(("  focusing %x %ld\n",
+	    DB(("  focusing %" FMT_WIN " %ld\n",
 		(unsigned) queued_focus_id, queued_focus_time));
 	    XSetInputFocus (dpy, queued_focus_id,
 			    queued_focus_revert, queued_focus_time);
@@ -233,6 +242,8 @@ get_window_protocols (Lisp_Window *w)
     int n;
     w->does_wm_take_focus = 0;
     w->does_wm_delete_window = 0;
+    if (debug_windows & DB_WINDOWS_REST)
+        DB (("W: %s: %s\n",__FUNCTION__,rep_STR(w->name)));
     if (XGetWMProtocols (dpy, w->id, &prot, &n) != 0)
     {
 	int i;
@@ -241,12 +252,14 @@ get_window_protocols (Lisp_Window *w)
 	    if (prot[i] == xa_wm_take_focus)
 	    {
 		w->does_wm_take_focus = 1;
-		DB(("  WM_TAKE_FOCUS is set\n"));
+                if (debug_windows & DB_WINDOWS_PROT)
+                    DB (("W:   WM_TAKE_FOCUS is set\n"));
 	    }
 	    if (prot[i] == xa_wm_delete_window)
 	    {
 		w->does_wm_delete_window = 1;
-		DB(("  WM_DELETE_WINDOW is set\n"));
+                if (debug_windows & DB_WINDOWS_PROT)
+                    DB (("W:   WM_DELETE_WINDOW is set\n"));
 	    }
 	}
 	XFree (prot);
@@ -281,8 +294,12 @@ find_window_by_id (Window id)
 {
     Lisp_Window *w;
     w = window_list;
+    if (debug_windows & DB_WINDOWS_FIND)
+        DB(("%s searching for %" FMT_WIN "\n", __FUNCTION__, id));
     while (w != 0 && w->id != id && w->frame != id)
 	w = w->next;
+    if (debug_windows & DB_WINDOWS_FIND)
+        DB(("%s %sfound\n", __FUNCTION__, (w)?"":"not "));
     if (w != 0 && WINDOW_IS_GONE_P (w))
 	w = 0;
     return w;
@@ -303,7 +320,8 @@ x_find_window_by_id (Window id)
 void
 install_window_frame (Lisp_Window *w)
 {
-    DB(("install_window_frame (%s)\n", rep_STR(w->name)));
+    if ((debug_windows & DB_WINDOWS_FRAME) || debug_frames)
+        DB (("%s%s%s on %s\n", reparent_color,__FUNCTION__, color_reset, rep_STR(w->name)));
     if (!w->reparented && w->frame != 0 && !WINDOW_IS_GONE_P (w))
     {
 	XSetWindowAttributes wa;
@@ -311,6 +329,9 @@ install_window_frame (Lisp_Window *w)
 	XSelectInput (dpy, w->frame, FRAME_EVENTS);
 
 	before_local_map (w);
+        if (debug_windows & DB_WINDOWS_FRAME)
+            DB(("%sXReparentWindow: %" FMT_WIN " %s -> %" FMT_WIN "%s\n", reparent_color,
+                w->id, rep_STR(w->name), w->frame, color_reset));
 	XReparentWindow (dpy, w->id, w->frame, -w->frame_x, -w->frame_y);
 	w->reparented = TRUE;
 	after_local_map (w);
@@ -326,16 +347,18 @@ install_window_frame (Lisp_Window *w)
 	wa.win_gravity = StaticGravity;
 	XChangeWindowAttributes (dpy, w->id, CWWinGravity, &wa);
 
-	DB(("  reparented to %lx [%dx%d%+d%+d]\n",
-	    w->frame, w->frame_width, w->frame_height,
-	    w->frame_x, w->frame_y));
+        if (debug_windows & DB_WINDOWS_FRAME)
+            DB(("  reparented to %" FMT_WIN " [%dx%d%+d%+d]\n",
+                w->frame, w->frame_width, w->frame_height,
+                w->frame_x, w->frame_y));
     }
 }
 
 void
 remove_window_frame (Lisp_Window *w)
 {
-    DB(("remove_window_frame (%s)\n", rep_STR(w->name)));
+    if (debug_windows & DB_WINDOWS_FRAME)
+        DB (("%s%s%s %s\n", reparent_color, __FUNCTION__, color_reset, rep_STR(w->name)));
     if (w->reparented && !WINDOW_IS_GONE_P (w))
     {
 	XSetWindowAttributes wa;
@@ -345,6 +368,8 @@ remove_window_frame (Lisp_Window *w)
 	wa.win_gravity = w->attr.win_gravity;
 	XChangeWindowAttributes (dpy, w->id, CWWinGravity, &wa);
 
+        DB(("%sXReparentWindow: %" FMT_WIN " %s%s -> root_window at %s%d,%d%s\n", reparent_color,
+            w->id, rep_STR(w->name), color_reset, reparent_color, w->attr.x, w->attr.y, color_reset));
 	before_local_map (w);
 	XReparentWindow (dpy, w->id, root_window, w->attr.x, w->attr.y);
 	w->reparented = FALSE;
@@ -356,6 +381,9 @@ remove_window_frame (Lisp_Window *w)
 
 	if (!w->mapped)
 	    XRemoveFromSaveSet (dpy, w->id);
+    } else {
+        if (debug_windows & DB_WINDOWS_FRAME)
+            DB (("%s: window is gone, or reparented outside, doing nothing\n", __FUNCTION__));
     }
 }
 
@@ -432,6 +460,13 @@ Lisp_Window *
 add_window (Window id)
 {
     Lisp_Window *w = rep_ALLOC_CELL(sizeof (Lisp_Window));
+
+    if (debug_windows & DB_WINDOWS_ADD) {
+        if (id == root_window)
+            DB (("W: add_window (ROOT)\n"));
+        else
+            DB (("W: add_window (%" FMT_WIN ")\n", id));
+    };
     if (w != 0)
     {
 	rep_GC_root gc_win;
@@ -440,11 +475,6 @@ add_window (Window id)
 	unsigned int xwcm;
 	long supplied;
 
-	DB(("add_window (%lx)\n", id));
-
-	if (id == root_window)
-	    DB(("  ** adding root window!?\n"));
-
 	rep_data_after_gc += sizeof (Lisp_Window);
 	memset (w, 0, sizeof (Lisp_Window));
 
@@ -501,9 +531,10 @@ add_window (Window id)
 	    w->shaped = bounding ? 1 : 0;
 	}
 
-	DB(("  name=`%s' x=%d y=%d width=%d height=%d\n",
-	    rep_STR(w->name), w->attr.x, w->attr.y,
-	    w->attr.width, w->attr.height));
+         if (debug_windows & DB_WINDOWS_ADD)
+             DB (("W:   name=`%s' x=%d y=%d width=%d height=%d\n",
+                  rep_STR(w->name), w->attr.x, w->attr.y,
+                  w->attr.width, w->attr.height));
 
 	xwcm = CWX | CWX | CWWidth | CWHeight | CWBorderWidth;
 	xwc.x = w->attr.x;
@@ -745,6 +776,11 @@ Note that these are Lisp properties not X properties.
 {
     repv plist;
     rep_DECLARE1(win, XWINDOWP);
+    if (debug_windows & DB_WINDOWS_PUT){
+       DB(("%s %s prop: %s\n", __FUNCTION__, rep_STR(VWIN(win)->name),
+           rep_SYMBOLP(prop)? (char*)rep_STR(rep_SYM(prop)->name):"not a symbol"));
+       /* Fbacktrace(Fstderr_file()); //Fbacktrace(Qnil);*/
+    }
     plist = VWIN(win)->plist;
     while (rep_CONSP(plist) && rep_CONSP(rep_CDR(plist)))
     {
@@ -893,6 +929,12 @@ new frame constructed as specified by FRAME.
 {
     rep_DECLARE1(win, WINDOWP);
     rep_DECLARE2(frame, rep_LISTP);
+
+    if (debug_frames && debug_windows) {
+        DB(("%s:%s\n", __FUNCTION__, rep_STR(VWIN(win)->name)));
+        Fbacktrace(Fstderr_file());
+    }
+
     Fgrab_server ();
 
     if (VWIN(win)->reparented)
@@ -918,6 +960,11 @@ Reinitialises and recalibrates the window frame of WINDOW.
     rep_DECLARE1(win, WINDOWP);
     if (VWIN(win)->frame != 0 && VWIN(win)->rebuild_frame != 0)
     {
+        if (debug_frames || (debug_windows & DB_WINDOWS_FRAME))
+            DB(("%s: %s->rebuild_frame %d %d\n", __FUNCTION__,
+                rep_STR(VWIN(win)->name),
+                VWIN(win)->attr.width,VWIN(win)->attr.height));
+
 	VWIN(win)->rebuild_frame (VWIN(win));
 	refresh_frame_parts (VWIN(win));
 	Fcall_window_hook (Qafter_framing_hook, win, Qnil, Qnil);
@@ -1382,6 +1429,8 @@ description of HOOK-TYPE.
     tem = Fwindow_get (win, hook, Qnil);
     if (tem && tem != Qnil)
     {
+        if (debug_windows & DB_WINDOWS_HOOKS)
+            DB (("W: call-window-hook: private %s\n", window_name (VWIN(win))));
 	tem = Fcall_hook (tem, args, type);
 	if (!tem || (type == Qand && tem == Qnil)
 	    || (type == Qor && tem != Qnil))
@@ -1389,7 +1438,11 @@ description of HOOK-TYPE.
 	    goto out;
 	}
     }
+    if (debug_windows & DB_WINDOWS_HOOKS)
+        DB (("W: call-window-hook: public %s\n",  window_name (VWIN(win))));
     tem = Fcall_hook (hook, args, type);
+    if (debug_windows & DB_WINDOWS_HOOKS)
+        DB (("W: call-window-hook: end %s\n",  window_name (VWIN(win))));
 out:
     rep_POPGC; rep_POPGC; rep_POPGC;
     return tem;
@@ -1542,16 +1595,22 @@ static void
 window_prin (repv stream, repv win)
 {
     char buf[128];
-    sprintf (buf, "#<window %lx>", VWIN(win)->id);
+    snprintf (buf, sizeof(buf), "#<window %" FMT_WIN " %s>", VWIN(win)->id, rep_STR(VWIN(win)->name));
     rep_stream_puts (stream, buf, -1, FALSE);
 }
 
 static void
 window_mark (repv win)
 {
+    if (debug_windows & DB_WINDOWS_GC)
+        DB(("%s: %p %s\n", __FUNCTION__, (void*) win, rep_STR(VWIN(win)->name)));
     rep_MARKVAL(VWIN(win)->plist);
     rep_MARKVAL(VWIN(win)->frame_style);
+    if (debug_windows & DB_WINDOWS_GC)
+       DB(("%s: now frame parts\n", __FUNCTION__));
     mark_frame_parts (VWIN(win));
+    if (debug_windows & DB_WINDOWS_GC)
+       DB(("%s: now strings\n", __FUNCTION__));
     rep_MARKVAL(VWIN(win)->name);
     rep_MARKVAL(VWIN(win)->full_name);
     rep_MARKVAL(VWIN(win)->icon_name);
@@ -1569,6 +1628,10 @@ window_mark_type (void)
     {
 	if (!WINDOW_IS_GONE_P (w) || !w->destroyed)
 	    rep_MARKVAL(rep_VAL(w));
+         else
+             if (debug_windows & DB_WINDOWS_GC)
+                 DB(("%s: %snot marking%s %p %s\n", __FUNCTION__, warning_color, color_reset,
+                     w, rep_STR(w->name)));
     }
     for (ph = prop_handlers; ph != 0; ph = ph->next)
 	rep_MARKVAL (ph->prop);
@@ -1579,12 +1642,17 @@ static void
 window_sweep (void)
 {
     Lisp_Window **ptr = &window_list;
+
+    if (debug_windows & DB_WINDOWS_GC)
+       DB(("%s\n", __FUNCTION__));
     while (*ptr != 0)
     {
 	Lisp_Window *w = *ptr;
 	if (!rep_GC_CELL_MARKEDP(rep_VAL(w)))
 	{
 	    assert (!window_in_stacking_list_p (w));
+            if (debug_windows & DB_WINDOWS_GC)
+                DB(("%s another window gone pointer: %p\n", __FUNCTION__, w));
 	    destroy_window_frame (w, FALSE);
 	    if (w->wmhints != 0)
 		XFree (w->wmhints);
@@ -1599,6 +1667,8 @@ window_sweep (void)
 	    rep_GC_CLR_CELL(rep_VAL(w));
 	}
     }
+    if (debug_windows & DB_WINDOWS_GC)
+        DB(("%s END\n", __FUNCTION__));
 }
 
 /* initialisation */
@@ -1610,6 +1680,8 @@ manage_windows (void)
     unsigned int nchildren, i;
     int revert_to;
 
+    if (debug_windows & DB_WINDOWS_REST)
+        DB(("%s\n", __FUNCTION__));
     Fgrab_server ();
 
     XGetInputFocus (dpy, &focus, &revert_to);
@@ -1629,8 +1701,13 @@ manage_windows (void)
 	}
 	focus = child;
     }
+   else if (debug_windows & DB_WINDOWS_REST)
+       DB(("%s: (focus != PointerRoot)\n", __FUNCTION__));
 
     XQueryTree (dpy, root_window, &root, &parent, &children, &nchildren);
+    if (debug_windows & DB_WINDOWS_REST)
+        DB(("%s: XQueryTree returned %d children\n",__FUNCTION__, nchildren));
+
     initialising = TRUE;
     restack_fast = TRUE;
     for (i = 0; i < nchildren; i++)

--- a/src/x.c
+++ b/src/x.c
@@ -50,6 +50,9 @@
 
 static int have_dbe;
 
+#include "debug.h"
+#include "debug-colors.h"
+
 /* An allocated x-gc */
 typedef struct lisp_x_gc {
     repv car;
@@ -750,8 +753,11 @@ x-map-window X-WINDOW [UNRAISED]
     rep_DECLARE1 (win, X_WINDOWP);
     if (unraised == Qnil)
 	XMapRaised (dpy, VX_DRAWABLE (win)->id);
-    else
+    else {
+        if (debug_windows & DB_WINDOWS_REST)
+            DB (("%s%s%s: mapping\n", map_request_color, __FUNCTION__, color_reset));
 	XMapWindow (dpy, VX_DRAWABLE (win)->id);
+    }
     return Qt;
 }
 
@@ -762,6 +768,8 @@ x-unmap-window X-WINDOW
 ::end:: */
 {
     rep_DECLARE1 (win, X_WINDOWP);
+    if (debug_windows & DB_WINDOWS_REST)
+       DB (("%s%s%s: UN-mapping\n", unmap_request_color, __FUNCTION__, color_reset));
     XUnmapWindow (dpy, VX_DRAWABLE (win)->id);
     return Qt;
 }
@@ -835,6 +843,9 @@ Destroys the X-DRAWABLE.
     if (X_WINDOWP (drawable))
     {
 	deregister_event_handler (VX_DRAWABLE (drawable)->id);
+        if (debug_windows & DB_WINDOWS_REST)
+            DB (("%s%s%s: destroying %x\n", unmap_request_color, __FUNCTION__, color_reset,
+                 VX_DRAWABLE (drawable)->id));
 	XDestroyWindow (dpy, VX_DRAWABLE (drawable)->id);
     }
     else if (X_PIXMAPP (drawable) || X_BITMAPP (drawable))
@@ -957,8 +968,10 @@ DEFUN ("x-window-back-buffer", Fx_window_back_buffer,
     buf = x_back_buffer_from_id (id);
     if (buf == 0)
     {
+        DB(("%s XdbeAllocateBackBufferName ...", __FUNCTION__));
 	buf = XdbeAllocateBackBufferName (dpy, id, XdbeBackground);
 	XSaveContext (dpy, id, x_dbe_context, (XPointer) buf);
+        DB(("-> %p\n", buf));
     }
 
     if (buf == 0)