anchor.diff:  
   (defclass presentation-type ()
     ((type-name :accessor type-name :initarg :type-name
  -	      :documentation "The name assigned to the presentation
  +              :documentation "The name assigned to the presentation
   type, as opposed to the name constructed for the class")
      (ptype-specializer :accessor ptype-specializer :initarg :ptype-specializer)
      (parameters :accessor parameters :initarg :parameters :initform nil)
      (parameters-lambda-list :accessor parameters-lambda-list
  -			   :initarg :parameters-lambda-list
  -			   :initform nil
  -			   :documentation "The parameters lambda list, altered for use in destructuring bind")
  +                           :initarg :parameters-lambda-list
  +                           :initform nil
  +                           :documentation "The parameters lambda list, altered for use in destructuring bind")
      (options :accessor options :initarg :options :initform nil)
      (options-lambda-list :accessor options-lambda-list
  -			:initarg :options-lambda-list
  -			:initform nil
  -			:documentation "The options lambda list,
  +                        :initarg :options-lambda-list
  +                        :initform nil
  +                        :documentation "The options lambda list,
   altered for use in destructuring bind")
      (inherit-from :accessor inherit-from
  -		 :initarg :inherit-from
  -		 :documentation "Inherit-from form with dummys substituted")
  +                 :initarg :inherit-from
  +                 :documentation "Inherit-from form with dummys substituted")
      (inherit-from-function :accessor inherit-from-function
  -			  :initarg :inherit-from-function
  -			  :documentation "Function that returns the inherit-from form")
  +                          :initarg :inherit-from-function
  +                          :documentation "Function that returns the inherit-from form")
      (description :accessor description :initarg :description)
      (history :accessor history :initarg :history :initform nil
  -	    :documentation "Who knows?")
  +            :documentation "Who knows?")
      (parameters-are-types :accessor parameters-are-types
  -			 :initarg :parameters-are-types
  -			 :initform nil)
  +                         :initarg :parameters-are-types
  +                         :initform nil)
      (expansion-function :accessor expansion-function
  -		       :initarg :expansion-function
  -		       :documentation "A function which expands the typespec
  +                       :initarg :expansion-function
  +                       :documentation "A function which expands the typespec
   fully, including defaulting parameters and options.")))
   
   (defmethod initialize-instance :after ((obj presentation-type) &key)
     (unless (slot-boundp obj 'ptype-specializer)
       (setf (slot-value obj 'ptype-specializer)
  -	  (make-presentation-type-name (slot-value obj 'type-name)))))
  +          (make-presentation-type-name (slot-value obj 'type-name)))))
   
   (defclass presentation-type-class (presentation-type standard-class)
     ())
   
  -(defmethod clim-mop:validate-superclass ((class presentation-type-class) 
  -					 (super standard-class))
  +(defmethod clim-mop:validate-superclass ((class presentation-type-class)
  +                                         (super standard-class))
     t)
   
   (defclass clos-presentation-type (presentation-type)
     ((clos-class :accessor clos-class :initarg :clos-class
  -	       :documentation "Holds the class object of the CLOS class of this presentation type")))
  +               :documentation "Holds the class object of the CLOS class of this presentation type")))
   
   (defmethod initialize-instance :after ((obj clos-presentation-type)
  -				       &key (ptype-specializer
  -					     nil
  -					     ptype-specializer-p))
  +                                       &key (ptype-specializer
  +                                             nil
  +                                             ptype-specializer-p))
     (declare (ignore ptype-specializer))
     (unless ptype-specializer-p
       (setf (slot-value obj 'ptype-specializer)
  -	  (slot-value obj 'type-name))))
  +          (slot-value obj 'type-name))))
   
   (defmethod history ((ptype standard-class))
     "Default for CLOS types that are not defined explicitly as
  
positive.code:   ;; presentation throw.
    (multiple-value-call
        #'(lambda (object &optional (ptype context-type) options)
  	  (values object ptype options))
      (funcall (translator-function translator)
  	     (presentation-object presentation)
  	     :presentation presentation
  	     :context-type context-type
  	     :frame frame
  	     :event event
  	     :window window
  	     :x x
  	     :y y)))
  
  (defmethod call-presentation-translator
      ((translator presentation-action) presentation context-type
       frame event window x y)
    (funcall (translator-function translator)
  	   (presentation-object presentation)
  	   :presentation presentation
  	   :context-type context-type
  	   :frame frame
  	   :event event
  	   :window window
  	   :x x
  	   :y y)
    (values nil nil nil))
  
  (defun document-presentation-translator (translator
  					 presentation
  					 context-type
  					 frame
  					 event
  					 window
  					 x y
  					 &key (stream *standard-output*)
  					 (documentation-type :normal))
    (funcall (if (eq documentation-type :normal)
  	       (translator-documentation translator)
  	       (pointer-documentation translator))
  	   (presentation-object presentation)
  	   :presentation presentation
  	   :context-type context-type
  	   :frame frame
  	   :event event
  	   :window window
  	   :x x
  	   :y y
  	   :stream stream))
  
  ;;; :button is a pointer button state, for performing matches where we want to
  ;;; restrict the match to certain gestures but don't have a real event.
  
negative.code:      :button button)
      (when result
        (return-from find-innermost-presentation-match
          (values result result-translator result-context)))
      (map-applicable-translators
       #'(lambda (translator presentation context)
           (return-from find-innermost-presentation-match
             (values presentation translator context)))
       *null-presentation*
       input-context
       frame
  