anchor.diff:  don't contain `sofar'."
     #'(lambda (str) (search sofar str :test #'char-equal)))
   
  -(defun recdo-1 (sofar list fn matcher key)
  +(defun t-matcher (sofar) "A matcher that is always happy." #'(lambda (str) t))
  +
  +(defun recdo-1 (sofar list fn matcher key this-or-that)
     (cond ((null list))
  -        ((single list)
  +        ((single-p list)
            (funcall fn (car list)))
           (t (let ((char (one-char)))
                (etypecase char
                  (character
                   (vector-push-extend char sofar)
                   (recdo-1 sofar (remove-if-not (funcall matcher sofar) list :key key)
  -                         fn matcher key))
  +                         fn matcher key this-or-that))
                  (symbol
                   (cond ((eql char 'abort))
  -                      ((eql char 'this) (funcall fn (car list))))))))))
  -
  -(defun recdo (list fn &key (matcher #'pre-matcher) (key #'identity))
  +                      ((eql char 'this)
  +                       (funcall fn (if this-or-that sofar (car list)))))))))))
  +
  +(defun recdo (list fn &key (matcher #'pre-matcher) (key #'identity) this-or-that)
     (let ((sofar (make-array 0 :element-type 'character :fill-pointer t :adjustable t)))
  -    (recdo-1 sofar list fn matcher key)))
  +    (recdo-1 sofar list fn matcher key this-or-that)))
   
   (defun app ()
     (grab-keyboard *root*)
  -  (unwind-protect
  -       (recdo *apps* #'(lambda (app) (run app)))
  +  (unwind-protect (recdo *apps* #'(lambda (app) (run app)))
       (ungrab-keyboard *display*)))
   
   (defun finder ()
     (grab-keyboard *root*)
     (unwind-protect (recdo *windows* #'focus :key #'xclass :matcher #'in-matcher)
  +    (ungrab-keyboard *display*)))
  +
  +(defun ssh ()
  +  (grab-keyboard *root*)
  +  (unwind-protect (recdo (list 1 2)     ; not single-p nor null
  +                         #'(lambda (host) (run (format nil "xterm -e ssh ~a" host)))
  +                         :matcher #'t-matcher
  +                         :this-or-that t)
       (ungrab-keyboard *display*)))
   
   ;;; Mouse shorcuts
  
positive.code: (defshortcut (:control #\p) (focus (next #'1-)))
  (defshortcut (:control #\t) (focus *last*))
  (defshortcut (#\a) (app))
  (defshortcut (#\') (finder))
  (defshortcut (#\f) (fullscreen))
  (defshortcut (#\.) (center))
  (defshortcut (:shift #\.) (center))
  
  (defun send-prefix ()
    (let ((focus (input-focus *display*)))
      (when (win= focus *curr*)
        (send-event focus :key-press (make-event-mask :key-press)
                          :window focus
                          :code (code *prefix*)
                          :state (state *prefix*)))))
  (defshortcut (#\t) (send-prefix))
  
  (defvar last-button nil)
  (defvar last-x nil)
  
negative.code:   "Return non-nil if keycode is a modifier"
    (find keycode *mods-code* :test #'eql))
  
  ;;; App launcher, class finder, etc.
  (defparameter *abort* (compile-shortcut :control #\g))
  (defparameter *this* (compile-shortcut #\Return)
    "Validate THIS value even if it is ambiguous on more than one.")
  
  (defun single-p (list) (and (consp list) (null (cdr list))))
  
  (defun one-char ()
    "Get one char from the user. The keyboard should be grabbed before call."
  