anchor.diff:  (defrestart value-error)
   
   (defun evloop ()
  -  (do () ((eql (process-event *display* :handler *handlers* :discard-p t) 'quit))))
  +  (do () ((eql (xlib:process-event *display* :handler *handlers* :discard-p t) 'quit))))
   
   (defun main ()
     (load-rc)
   
     ;; Populate list of windows
  -  (dolist (w (query-tree *root*))
  -    (when (and (eql (window-map-state w) :viewable)
  -               (eql (window-override-redirect w) :off))
  +  (dolist (w (xlib:query-tree *root*))
  +    (when (and (eql (xlib:window-map-state w) :viewable)
  +               (eql (xlib:window-override-redirect w) :off))
         (plus w)))
   
  -  (intern-atom *display* :_MOTIF_WM_HINTS)
  -  (setf (window-event-mask *root*) '(:substructure-notify :substructure-redirect))
  +  (xlib:intern-atom *display* :_MOTIF_WM_HINTS)
  +  (setf (xlib:window-event-mask *root*) '(:substructure-notify :substructure-redirect))
   
     (setf *last* (setf *curr* (first *windows*)))
     (focus *curr*)
   
  -  (unwind-protect (handler-bind ((window-error #'restart-window-error)
  -                                 (value-error #'restart-value-error)
  +  (unwind-protect (handler-bind ((xlib:window-error #'restart-window-error)
  +                                 (xlib:value-error #'restart-value-error)
                                    (simple-error #'restart-simple-error))
                       (evloop))
       (ungrab-all)
  -    (close-display *display*)))
  +    (xlib:close-display *display*)))
   
   (main)
  
positive.code: 		      (incf y new-h)
  		      (setf height (abs new-h)))
  		     (t (setf height new-h)))))
      (with-state (window)
        (setf (drawable-x window) x
      	    (drawable-y window) y
      	    (drawable-width window) width
      	    (drawable-height window) height))
      (values x y width height dx dy dw dh)))
  
  (defun memove (window &optional x y w h)
    "Memory Move a window (i.e. toggle between current position and the
  given one). Without a given new position reset position or does
  nothing."
    (let ((dim (getf (window-plist window) 'original-dimension)))
      (cond (dim
             (apply #'move window dim)
             (remf (window-plist window) 'original-dimension))
            (t (when (and x y w h)
                 (setf (getf (window-plist window) 'original-dimension)
                       (list :x (drawable-x window) :y (drawable-y window)
                             :width (drawable-width window) :height (drawable-height window)))
                 (move window :x x :y y :width w :height h))))))
  
  (defun win= (a b)
    (and (typep a 'window) (typep b 'window) (window-equal a b)))
  
  (defun grouper (window)
    "Get the grouper function of a window if there is one."
  
negative.code: 
  (defhandler :map-request (parent send-event-p window)
    (format t "~&map-request: ~a ~a ~a~%" parent send-event-p window)
    (restart-case (xlib:map-window (plus window))
      (window-error (c)
        (format t "~&map-request: ~a ~a~%" c window)
        'processed)
  