anchor.diff:  
   (in-package :dwim)
   
  -#+clim
   ;;; I guess this is as good of a place as any to put this.
   (make-command-table :global)
   
  -#+clim
   (defun continuation-output-rectangle (continuation stream)
     ;; Repositioning the cursor seems to improve the reliability of
     ;; this computation in clim 0.9.
  -  #-clim-2
  -  (with-output-truncation (stream)
  -    (multiple-value-bind (x y) (stream-cursor-position* stream)
  -      (unwind-protect
  -	  (progn (stream-set-cursor-position* stream 100 100)
  -		 (let ((record (clim:with-output-to-output-record (stream)
  -				 (funcall continuation stream))))
  -		   (clim:bounding-rectangle record)))
  -	(stream-set-cursor-position* stream x y))))
  -  #+clim-2
     (let ((record (clim:with-output-to-output-record (stream)
   		  (funcall continuation stream))))
       (clim:bounding-rectangle record)))
   
   (defun continuation-output-size (continuation stream)
     ;;(declare (values width height))
  -  #FEATURE-CASE
  -  (((not :clim) (dw:continuation-output-size continuation stream))
  -   (:clim-0.9 (multiple-value-bind (width height)
  -		  (clim:bounding-rectangle-dimensions
  -		   (continuation-output-rectangle continuation stream))
  -		;; edges can be floats, so truncate them.
  -		(values (truncate width) (truncate height))))
  -   ((or :clim-1.0 :clim-2)
  -    (clim:rectangle-size
  -     (continuation-output-rectangle continuation stream)))))
  +  (clim:rectangle-size
  +   (continuation-output-rectangle continuation stream)))
   
   ;;;
   ;;; Manipulating presentations
   ;;;
   
  -#+clim-1.0
  -(progn
  -  (clim:define-gesture-name :left :button :left)
  -  (clim:define-gesture-name :middle :button :middle)
  -  (clim:define-gesture-name :right :button :right))
  -
  -#+clim-2
   (progn
     (clim:define-gesture-name :left :pointer-button :left)
     (clim:define-gesture-name :middle :pointer-button :middle)
     (clim:define-gesture-name :right :pointer-button :right))
   
   (defun erase-graphics-presentation (presentation &key (stream *standard-output*))
  -  #FEATURE-CASE
  -  (((not :clim)
  -    ;; Ordinarily, graphics:erase-graphics-presentation would be the right thing.
  -    ;; This modification makes one slight change to the procedure
  -    ;; so that the entire area is cleared at once, rather than erasing
  -    ;; every inferior ad nauseum.
  -    (when (typep stream 'dw:dynamic-window)
  -      (labels ((eraser (p)
  -		 (when (typep p 'dw:presentation)
  -		   (dolist (inf (scl:symbol-value-in-instance p 'dw::inferiors))
  -		     (eraser inf))
  -		   (setf (scl:symbol-value-in-instance p 'dw::inferiors) nil))
  -		 ;; delete from coordinate sorted set of window:
  -		 (if (typep p 'dw::text-displayed-presentation)
  -		     (dw::erase-displayed-presentation p stream t nil t)
  -		   (send stream :delete-graphics-displayed-presentation p))))
  -	(eraser presentation))
  -      ;; Delete from superior's list of inferiors:
  -      (send stream :delete-displayed-presentation presentation)
  -      ;; Clear the rectangle and redraw overlapping presentations:
  -      (send stream :redraw-inside-sets
  -	    (dw:presentation-displayed-box presentation) t)))
  -   ((or :clim-0.9 :clim-1.0)
  -    ;; If clim can't find the presentation, it signals an error.
  -    ;; As far as I'm concerned, if it can't find it, it's as good as erased.
  -    (multiple-value-bind (value errorp)
  -	(ignore-errors (clim:erase-output-record presentation stream))
  -      (if errorp
  -	  ;; If an error happened, the display is probably screwed up.
  -	  ;; So beep to admit responsibility and try somehow to recover.
  -	  (progn #+ig (beep)
  -		 (clim:output-recording-stream-replay stream presentation))
  -	value)))
  -   (:clim-2
  -    (clim:erase-output-record presentation stream nil))))
  +  (clim:erase-output-record presentation stream nil))
   
   (defun presentation-under-pointer (stream)
  -  #FEATURE-CASE
  -  (((not :clim) (scl:send stream :last-highlighted-presentation))
  -   (:clim-0.9 (ci::highlighted-presentation stream))
  -   (:clim-1.0 (multiple-value-bind (x y) (clim:stream-pointer-position* stream)
  -		(clim::find-innermost-applicable-presentation 
  -		 '((t)) stream x y)))
  -   (:clim-2 (multiple-value-bind (x y) (clim:stream-pointer-position stream)
  -		(clim::find-innermost-applicable-presentation '((t)) stream x y)))))
  +  (multiple-value-bind (x y) (clim:stream-pointer-position stream)
  +    (clim::find-innermost-applicable-presentation '((t)) stream x y)))
   
   (defun presentation-p (object)
  -  #FEATURE-CASE
  -  (((not :clim) (typep object 'dw::presentation))
  -   (:clim-0.9 (ci::presentation-p object))
  -   ((or :clim-1.0 :clim-2) (typep* object 'clim:presentation))))
  +  (typep object 'clim:presentation))
   
   (defun presentation-superior (presentation)
  -  #+clim (clim:output-record-parent presentation)
  -  #-clim (dw:presentation-superior presentation))
  +  (clim:output-record-parent presentation))
   
   (defun presentation-object (presentation)
  -  #-clim (dw:presentation-object presentation)
  -  #+clim (if (presentation-p presentation) (clim:presentation-object presentation)))
  +  (if (presentation-p presentation) (clim:presentation-object presentation)))
   
   (defun presentation-subtypep (subtype supertype)
  -  #-clim (dw:presentation-subtypep subtype supertype)
  -  #+clim (clim:presentation-subtypep subtype supertype))
  +  (clim:presentation-subtypep subtype supertype))
   
   (defun presentation-type-p (type)
  -  #-clim (dw:presentation-type-p type)
  -  #+clim (clim:presentation-type-specifier-p type))
  +  (clim:presentation-type-specifier-p type))
   
   (defun describe-presentation-type (type &optional (stream *standard-output*))
  -  #-clim (dw:describe-presentation-type type stream)
  -  #+clim (clim:describe-presentation-type type stream))
  +  (clim:describe-presentation-type type stream))
   
   (defun bounding-rectangle* (presentation)
     "Get the bounding edges of the presentation."
  -  ;;(declare (values left top right bottom))
  -  #FEATURE-CASE
  -  (((not :clim)
  -    (when (presentation-p presentation)
  -      (let ((box (dw:presentation-displayed-box presentation)))
  -	(if box (dw:box-edges box)))))
  -   (:clim-0.9
  -    (multiple-value-bind (left top right bottom)
  -	(clim:bounding-rectangle* presentation)
  -      ;; edges can be floats, so truncate them.
  -      (values (truncate left) (truncate top) (truncate right) (truncate bottom))))
  -   ((or :clim-1.0 :clim-2)
  -    (let ((stream *standard-output*))
  -      ;; Seem to need to know the stream under the presentation.
  -      ;; Take a wild guess.
  -      (multiple-value-bind (xoff yoff)
  -	  (#-mcclim clim::convert-from-relative-to-absolute-coordinates
  -	   #+mcclim climi::convert-from-relative-to-absolute-coordinates
  -	   stream
  -	   (clim::output-record-parent presentation))
  -	(clim:with-bounding-rectangle*
  -	    (left top right bottom) presentation
  -	    (values (+ left xoff) (+ top yoff) (+ right xoff) (+ bottom yoff))))))))
  +  (let ((stream *standard-output*))
  +    ;; Seem to need to know the stream under the presentation.
  +    ;; Take a wild guess.
  +    (multiple-value-bind (xoff yoff)
  +        (climi::convert-from-relative-to-absolute-coordinates
  +         stream
  +         (clim::output-record-parent presentation))
  +      (clim:with-bounding-rectangle*
  +          (left top right bottom) presentation
  +        (values (+ left xoff) (+ top yoff) (+ right xoff) (+ bottom yoff))))))
   
   (defun redisplay (record stream)
  -  #FEATURE-CASE
  -  (((not :clim) (dw:do-redisplay record stream :truncate-p nil))
  -   ((or :clim-1.0 :clim-2) (clim:redisplay record stream :check-overlapping nil))))
  +  (clim:redisplay record stream :check-overlapping nil))
   
   (defun redisplayable? (stream)
  -  #FEATURE-CASE
  -  ((:clim-2 (clim:redisplayable-stream-p stream))
  -   (:clim-1.0 (clim:stream-redisplayable-p stream))
  -   (:clim-0.9 (clim-internals::stream-redisplayable-p stream))
  -   ((not :clim) stream)))
  +  (clim:redisplayable-stream-p stream))
   
   (defun redisplayable-format (stream string &rest args)
     (if (eq stream 't) (setq stream *standard-output*))
  
positive.code: 		,@body))))
  
  (defmacro formatting-row ((stream) &body body)
    #-clim `(dw:formatting-row (,stream :dont-snapshot-variables t) ,@body)
    #+clim `(clim:formatting-row (,stream) ,@body))
  
  (defmacro formatting-column ((stream) &body body)
    #-clim `(dw:formatting-column (,stream :dont-snapshot-variables t) ,@body)
    #+clim `(clim:formatting-column (,stream) ,@body))
  
  (defmacro formatting-column-headings ((stream &key (underline-p nil)) &body body)
    #-clim `(dw:formatting-column-headings
  	    (,stream :underline-p ,underline-p :dont-snapshot-variables t)
  	    ,@body)
    ;; dont have the time to do this one justice.
    #+clim (if underline-p
  	     `(formatting-row (,stream) (with-underlining (,stream) ,@body))
  	     `(formatting-row (,stream) ,@body)))
  
  (defmacro formatting-cell ((stream &key (align-x :left) align-y) &body body)
    #+clim `(clim:formatting-cell (,stream ,@(if align-x `(:align-x ,align-x))
  					 ,@(if align-y `(:align-y ,align-y)))
  				 ,@body)
    #-clim `(dw:formatting-cell (,stream :align-x ,align-x :align-y ,align-y)
  			       ; :dont-snapshot-variables t ;;++This seems to not work
  	    ,@body))
  
  (defmacro formatting-item-list ((stream &rest options) &body body)
    #+clim `(clim:formatting-item-list (,stream ,@options) ,@body)
    #-clim `(dw:formatting-item-list (,stream ,@options) ,@body))
  
  (defmacro format-item-list (list &rest keys)
    #-clim `(dw:format-item-list ,list ,@keys)
    #+clim
    (let ((stream (or (second (member :stream keys)) t)))
      `(formatting-item-list (,stream)
         (dolist (item ,list)
  
negative.code: 		      (GESTURE-VAR   '.gesture. gesture-p))
  	   NON-BLIP-FORM
  	   &body CLAUSES)
    (declare (ignore stream))
    `(clim:with-input-context (,PRESENTATION-TYPE :override ,OVERRIDE)
  			    (,OBJECT-VAR ,PT-VAR ,@(if gesture-p GESTURE-VAR))
  	,NON-BLIP-FORM
  