anchor.diff:      (if (and (presentationp presentation)
                (presentation-subtypep (presentation-type presentation) 'blank-area))
           (loop
  -           for context in input-context
  -           do (process-presentation context presentation))
  +          for context in input-context
  +          do (process-presentation context presentation))
           (loop
  -           for context in input-context
  -           do (mopscp context presentation)))))
  +          for context in input-context
  +          do (mopscp context presentation)))))
   
   (defun window-modifier-state (window)
     "Provides default modifier state for presentation translator functions."
  
positive.code: 
  (defmacro define-presentation-action
      (name (from-type to-type command-table &key
             (gesture :select)
             (tester 'default-translator-tester)
             (documentation nil documentationp)
             (pointer-documentation nil pointer-documentation-p)
             (menu t)
             (priority 0))
       arglist
       &body body)
    (let* ((real-from-type (expand-presentation-type-abbreviation from-type))
           (real-to-type (expand-presentation-type-abbreviation to-type)))
      `(add-translator (presentation-translators (find-command-table ',command-table))
        (make-instance
         'presentation-action
         :name ',name
         :from-type ',real-from-type
         :to-type ',real-to-type
         :gesture ,(if (eq gesture t)
                       t
                       `(gethash ',gesture *gesture-names*))
         :tester ,(if (symbolp tester)
                      `',tester
                      `#',(make-translator-fun (car tester)
                                               (cdr tester)))
         :tester-definitive t
         :documentation #',(make-documentation-fun (if documentationp
                                                       documentation
                                                       (command-name-from-symbol
                                                        name)))
         ,@(when pointer-documentation-p
                 `(:pointer-documentation
                   #',(make-documentation-fun pointer-documentation)))
         :menu ',menu
         :priority ,priority
         :translator-function #',(make-translator-fun arglist body)))))
  
  (defmacro define-presentation-to-command-translator
      (name (from-type command-name command-table &key
             (gesture :select)
             (tester 'default-translator-tester)
             (documentation nil documentationp)
             (pointer-documentation (command-name-from-symbol command-name))
             (menu t)
             (priority 0)
             (echo t))
       arglist
       &body body)
    (let ((command-args (gensym "COMMAND-ARGS")))
  
negative.code:   (labels ((process-presentation (context presentation)
               (let* ((context-ptype (first context))
                      (maybe-translators
                        (find-presentation-translators (presentation-type presentation)
                                                       context-ptype
                                                       (frame-command-table frame))))
                 (loop for translator in maybe-translators
                       when (and (or (not for-menu) (eql for-menu (menu translator)))
                                 (test-presentation-translator
                                  translator presentation context-ptype
                                  frame window x y
                                  :event event :modifier-state modifier-state
                                  :for-menu for-menu :button button))
                         do (funcall func translator presentation context))))
             (mopscp (context record)
               "maps recursively over all presentations in record, including record."
               (if (and x y)
  