anchor.diff:  
   (defparameter *families* (list
                             #'(lambda (w) (search "Gimp" (xclass w) :test #'char-equal)))
  -  "List of predicates that tells if windows are of the same family.")
  +  "List of predicates to make some windows of the same family.")
   
   (defstruct (shortcut (:conc-name)) (states nil) (code 0))
   
  
positive.code:   (and (xlib:window-p a) (xlib:window-p b) (xlib:window-equal a b)))
  
  (defun family (window)
    "Get the family of a window."
    (let ((family-fun (and window (restart-case (find-if #'(lambda (f) (funcall f window)) *families*)
                                    (window-error (c) nil)))))
      (when (functionp family-fun)
        (loop for w in *windows* when (funcall family-fun w) collect w))))
  
  (defun get-transients-of (window)
    (restart-case
  
negative.code:       (format t "~&get-transients-of: ~a ~a~%" c window)
        nil)))
  
  (defun focus (window)
    "Focus one window and its family if needed."
    (when window
      (labels ((up (win)
                 (setf (xlib:window-priority win) :above)
                 (dolist (w (get-transients-of win))
                   (setf (xlib:window-priority w) :above))))
        (let ((family (sort (family window) #'< :key #'xlib:window-id)))
          (cond (family
                 ;; focus every other family members and set input
                 ;; focus as follow mouse
                 (unless (member *curr* family :test #'win=)
                   (setf *last* *curr*
                         *curr* (first family)))
                 (dolist (w family) (up w))
                 (xlib:set-input-focus *display* :pointer-root :pointer-root))
                (t
                 ;; set input focus to window
                 (unless (win= *curr* window)
                   (setf *last* *curr*
                         *curr* window))
                 (xlib:set-input-focus *display* window :pointer-root)))
          (up window)))))
  
  (defun next (&optional (way #'1+))
    (let* ((family (family *curr*))
           (windows (set-difference *windows* family :test #'win=))
           (n (length windows))
           (nw (or (position *curr* windows :test #'win=) 0)))
      (unless (zerop n)
  