anchor.diff:    (event-case (*display*)
       (:key-press (code state)
                   (cond ((is-modifier code) (one-char))
  -                      ((and (= state (state *abort*)) (= code (code *abort*))))
  +                      ((sc= *abort* state code) *abort*)
  +                      ((sc= *this* state code) *this*)
                         (t (keycode->character *display* code state))))))
   
   (defun recapp (pos list)
  
positive.code:                                      ((eq fn 'quit) (loop-finish))))))
                           (ungrab-keyboard *display*)
                           (setf waiting-shortcut nil)))
                        ((and (= state (state *prefix*)) (= code (code *prefix*)))
                         (grab-keyboard *root*)
                         (setf waiting-shortcut t))))
                 (:button-press
                  (code state child)
                  (when (and child (eql (window-override-redirect child) :off))
                    (cond ((and (= code (code *kill*))
                                (= state (state *kill*)))
                           (kill-client *display* (window-id child)))
                          (t
                           (setf last-button code)
                           (grab-pointer child '(:pointer-motion :button-release))
                           (when (and (= code (code *resize*))
                                      (= state (state *resize*)))
                             (warp-pointer child (drawable-width child)
                                           (drawable-height child)))
                           (let ((lst (multiple-value-list (query-pointer *root*))))
  
negative.code:         ((single list)
           (run-program (car list) nil :wait nil :search t))
          (t (let ((char (one-char)))
               (etypecase char
                 (character
                  (let ((sublist (remove-if #'(lambda (str)
                                                (or (>= pos (length str))
                                                    (char/= (elt str pos) char))) list)))
                    (recapp (1+ pos) sublist)))
                 (cons
                  (cond ((sc= char (state *abort*) (code *abort*)))
                        ((sc= char (state *this*) (code *this*))
                         (let ((sublist (remove-if #'(lambda (str) (/= (length str) pos))
                                                   list)))
                           (recapp (1+ pos) sublist))))))))))
  
  (defun app ()
    (grab-keyboard *root*)
  