anchor.diff:      (translator presentation context-type frame window x y
        &key event (modifier-state 0) for-menu button)
     (flet ((match-gesture (gesture event modifier-state)
  -	   (let ((modifiers (if event
  -				(event-modifier-state event)
  -				modifier-state)))
  -	     (or (eq gesture t)
  -		 for-menu
  -		 (loop for g in gesture
  -		       thereis (and (eql modifiers (caddr g))
  -				    (or (and button (eql button (cadr g)))
  -					(and (null button)
  -					     (or (null event)
  -						 (eql (pointer-event-button
  -						       event)
  -						      (cadr g)))))))))))
  +           (let ((modifiers (if event
  +                                (event-modifier-state event)
  +                                modifier-state)))
  +             (or (eq gesture t)
  +                 for-menu
  +                 (loop for g in gesture
  +                       thereis (and (eql modifiers (caddr g))
  +                                    (or (and button (eql button (cadr g)))
  +                                        (and (null button)
  +                                             (or (null event)
  +                                                 (eql (pointer-event-button
  +                                                       event)
  +                                                      (cadr g)))))))))))
       (let* ((from-type (from-type translator)))
         (unless (match-gesture (gesture translator) event modifier-state)
  -	(return-from test-presentation-translator nil))
  +        (return-from test-presentation-translator nil))
         (unless (or (null (decode-parameters from-type))
  -		  (presentation-typep (presentation-object presentation)
  -				      from-type))
  -	(return-from test-presentation-translator nil))
  +                  (presentation-typep (presentation-object presentation)
  +                                      from-type))
  +        (return-from test-presentation-translator nil))
         (unless (or (null (tester translator))
  -		  (funcall (tester translator)
  -			   (presentation-object presentation)
  -			   :presentation presentation
  -			   :context-type context-type
  -			   :frame frame
  -			   :window window
  -			   :x x
  -			   :y y
  -			   :event event))
  -	(return-from test-presentation-translator nil))
  +                  (funcall (tester translator)
  +                           (presentation-object presentation)
  +                           :presentation presentation
  +                           :context-type context-type
  +                           :frame frame
  +                           :window window
  +                           :x x
  +                           :y y
  +                           :event event))
  +        (return-from test-presentation-translator nil))
         (unless (or (tester-definitive translator)
  -		  (null (decode-parameters context-type))
  -		  (presentation-typep (call-presentation-translator
  -				       translator
  -				       presentation
  -				       context-type
  -				       frame
  -				       event
  -				       window
  -				       x y)
  -				      context-type))
  -	(return-from test-presentation-translator nil))))
  +                  (null (decode-parameters context-type))
  +                  (presentation-typep (call-presentation-translator
  +                                       translator
  +                                       presentation
  +                                       context-type
  +                                       frame
  +                                       event
  +                                       window
  +                                       x y)
  +                                      context-type))
  +        (return-from test-presentation-translator nil))))
     t)
   
   ;;; presentation-contains-position moved to presentation-defs.lisp
  
positive.code:      &key event (modifier-state (window-modifier-state window)) for-menu fastp)
    (let ((results nil))
      (flet ((fast-func (translator presentation context)
  	     (declare (ignore translator presentation context))
  	     (return-from find-applicable-translators t))
  	   (slow-func (translator presentation context)
  	     (push (list translator presentation (input-context-type context))
  		   results)))
        (map-applicable-translators (if fastp #'fast-func #'slow-func)
  				  presentation input-context frame window x y
  				  :event event
  				  :modifier-state modifier-state
  				  :for-menu for-menu)
        (nreverse results))))
  
  (defun presentation-matches-context-type
      (presentation context-type frame window x y &key event (modifier-state 0))
    (let* ((ptype (expand-presentation-type-abbreviation (presentation-type
  						       presentation)))
  	 (ctype (expand-presentation-type-abbreviation context-type))
  	 (translators (find-presentation-translators ptype
  						     ctype
  						     (frame-command-table
  						      frame))))
      (loop for translator in translators
  	  if (test-presentation-translator translator
  					   presentation
  					   ctype
  					   frame
  					   window
  					   x y
  					   :event event
  					   :modifier-state modifier-state)
  	  do (return-from presentation-matches-context-type t))
      nil))
  
  ;;; 23.7.3 Finding Applicable Presentations
  
negative.code: (defmethod get-ptype-metaclass ((type symbol))
    (let ((maybe-meta (gethash type *presentation-type-table*)))
      (if maybe-meta
          (get-ptype-metaclass maybe-meta)
          (let ((system-meta (find-class type nil)))
            (and (typep system-meta 'standard-class)
                 system-meta)))))
  
  (defmethod get-ptype-metaclass ((type presentation-type-class))
    type)
  