anchor.diff:  	       (progn
   		 (clim:run-frame-top-level frame))
   	     (deactivate-frame frame)))))
  -   ((not :clim)
  -    (cond (master (error "MASTER operation not supported."))
  -	  ((not wait-until-done)
  -	   (scl:send frame :mouse-select))
  -	  (T
  -	   (setf (scl:symbol-value-in-instance frame 'tv:process) nil)
  -	   (let* ((superior (scl:send frame :superior))
  -		  (shadow (if (typep* superior 'tv:basic-screen)
  -			      (first (scl:send superior :exposed-inferiors))))
  -		  (dw:*program-frame* frame)
  -		  (dw:*program* (scl:send frame :program)))
  -	     (tv:with-window-shadowed-for-selection (shadow frame :reselect t)
  -	       (tv:window-call (frame :deactivate)
  -			       (unwind-protect
  -				   (dw::run-program-top-level dw:*program*)
  -				 (deactivate-frame frame))))))))))
   
   (defun make-application-frame (type &key parent title 
   					 (left 10) (top 10)
   					 (width 500) (height 500))
  -  #FEATURE-CASE
  -  (((not :clim)
  -    (tv:make-window 'dw::program-frame  ; 'dw::program-frame-resource
  -		    :superior parent
  -		    :program type
  -		    :margin-components
  -		    '((dw:margin-drop-shadow-borders) (dw:margin-borders))
  -		    :program-state-variables `((dw::pretty-name ,title))))
  -   (:clim-0.9
  -    (let ((frame (clim:make-frame type :title title)))
  -      (ws::adopt-frame parent frame)
  -      (setf (ws::frame-prop frame :reusable) t)
  -      frame))
  -   (:clim-1.0
  -    ;; Also, note you can (currently) get into trouble in Lucid if you use a
  -    ;; single root window for multiple frames.  X events for the root can be
  -    ;; snagged by any frame's process without regard which frame should "own"
  -    ;; the event.  The workaround is to open a new root window for each frame.
  -    ;;--David Gadbois
  -    (clim:make-application-frame
  -     type
  -     ;; 9-15-93 When `launch-frame' calls us with a parent we need to
  -     ;; use it, otherwise mouse-sensitivity does not work. (Westy)
  -     :parent (or parent (find-frame-manager :if-exists :create))
  -     :pretty-name title
  -     :left left :top top :right (+ left width) :bottom (+ top height)))
  -   (:clim-2
  -    ;; what parent does this get?
  -    (let ((frame (clim:make-application-frame
  -		  type
  -		  :pretty-name title
  -		  :left left :top top
  -		  :width width :height height
  -                  :frame-manager
  -                  parent)))
  -      frame))))
  +  (let ((frame (clim:make-application-frame
  +                type
  +                :pretty-name title
  +                :left left :top top
  +                :width width :height height
  +                :frame-manager
  +                parent)))
  +    frame))
   
   (defmethod size-frame (frame width height)
  -  #FEATURE-CASE
  -  (((not :clim) (scl:send frame :set-edges 0 0 width height))
  -   (:clim-0.9 (ws::size-frame frame width height))
  -   (:clim-2
  -    (clim:layout-frame frame width height))      
  -   (:clim-1.0
  -    (let ((window (clim:frame-top-level-window frame)))
  -      (multiple-value-bind (xmin ymin xmax ymax)
  -	  (clim:bounding-rectangle* (sheet-parent window))
  -	(declare (ignore xmin ymin))
  -	(multiple-value-bind (left top) (clim:bounding-rectangle* window)
  -	  (setf (clim:bounding-rectangle-max-x window) (min (+ left width) xmax))
  -	  (setf (clim:bounding-rectangle-max-y window) (min (+ top height) ymax))
  -	  (clim::layout-frame-panes frame window)))))))
  +  (clim:layout-frame frame width height))
   
   (defmethod move-frame (frame left bottom)
  -  #FEATURE-CASE
  -  (((not :clim) (dw::position-window-near-carefully frame `(:point ,left ,bottom)))
  -   (:clim-0.9 (ws::move-frame frame left bottom))
  -   (:clim-1.0 (clim::position-window-near-carefully
  -	       (clim:frame-top-level-window frame)
  -	       left bottom))
  -   ((and :clim-2 (not :mcclim))
  -    (clim:position-sheet-carefully (clim:frame-top-level-sheet frame)
  -				   left bottom))
  -   ;; uhh...
  -   (:mcclim nil)))
  +  ;; CLH: FIXME! What are we supposed to do here?
  +  ;; uhh...
  +  nil)
   
   (defmethod get-frame-pane (frame pane-name)
  -  #FEATURE-CASE
  -  (((not :clim) (scl:send frame :get-pane pane-name))
  -   (:clim-1.0 (clim:get-frame-pane frame pane-name))
  -   (:clim-2 (clim:get-frame-pane frame pane-name))))
  +  (clim:get-frame-pane frame pane-name))
   
   (defmethod frame-current-layout (frame)
  -  #FEATURE-CASE
  -  (((or :clim-1.0 :clim-2) (clim:frame-current-layout frame))
  -   ((not :clim) (scl:send frame :configuration))))
  +  (clim:frame-current-layout frame))
   
   (defmethod set-frame-layout (frame new-layout)
  -  #FEATURE-CASE
  -  ((:clim-1.0
  -    ;; In clim 1.0 at least, this does a THROW out of the command loop
  -    ;; to do certain window management functions, such as rebinding I/O
  -    ;; streams that correspond to the new layout.  So do this last in
  -    ;; a sequence of operations.
  -    (unless (eq new-layout (frame-current-layout frame))
  -      (clim:set-frame-layout frame new-layout)))
  -   (:clim-2
  -    (unless (eq new-layout (frame-current-layout frame))
  -      (setf (clim:frame-current-layout frame) new-layout)))
  -   ((not :clim)
  -    (unless (eq new-layout (frame-current-layout frame))
  -      (if (or (not (boundp 'dw::*program-frame*))
  -	      (not (eql frame dw::*program-frame*)))
  -	  (scl:send frame :set-configuration new-layout)
  -	(scl:send frame :synchronous-set-configuration new-layout))))))
  +  (unless (eq new-layout (frame-current-layout frame))
  +    (setf (clim:frame-current-layout frame) new-layout)))
   
   (defmethod window-set-viewport-position* (stream left top)
  -  #FEATURE-CASE
  -  ((:clim-0.9 (clim:set-scroll-position stream left top))
  -   (:clim-1.0
  -     (clim:window-set-viewport-position* stream left top)
  -     (clim::redisplay-decorations stream))
  -   ((and :clim-2 (not :mcclim))
  -    (clim:window-set-viewport-position stream left top))
  -   (:mcclim
  -    (setf (clim:window-viewport-position stream) (values left top)))
  -   ((not :clim) (scl:send-if-handles stream :set-viewport-position left top))))
  +  (setf (clim:window-viewport-position stream) (values left top)))
   
   (defmethod window-history-limits (stream)
     ;;(declare (values left top right bottom))
  -  #+(or (not clim) clim-0.9) (declare (ignore stream))
  -  #FEATURE-CASE
  -  ((:clim-1.0
  -    (let ((history (clim:output-recording-stream-output-record stream)))
  -      (clim:bounding-rectangle* history)))
  -   (:clim-2
  -    (let ((history (clim:stream-output-history stream)))
  -      (clim:bounding-rectangle* history)))))
  +  (let ((history (clim:stream-output-history stream)))
  +    (clim:bounding-rectangle* history)))
   
   (defmethod select-frame (frame)
  -  #FEATURE-CASE
  -  (((not :clim) (scl:send frame :mouse-select))
  -   (:clim-1.0
  -    (let ((window (clim:frame-top-level-window frame)))
  -      #+xlib
  -      (xlib:map-window (slot-value window 'clim::window)) ; deiconify
  -      (clim:window-stack-on-top window)
  -      (force-output window)
  -      frame))
  -   (:clim-2
  -    (note-frame-deiconified
  -     (clim:frame-manager frame) frame)
  -    (clim:raise-sheet (clim:frame-top-level-sheet frame))
  -    frame)))
  +  (note-frame-deiconified
  +   (clim:frame-manager frame) frame)
  +  (clim:raise-sheet (clim:frame-top-level-sheet frame))
  +  frame)
   
   (defun suggest-frame-size (frame-manager width height)
  -  #FEATURE-CASE
  -  (((not :clim)
  -    (multiple-value-bind (w h) (scl:send frame-manager :size)
  -      (setq width (min width w)
  -	    height (min height h))))
  -   (:clim-0.9
  -    (let ((graft (clim-shared:graft frame-manager)))
  -      (when graft
  -	(setq width (min width (clim-shared::graft-width-pixel graft))
  -	      height (min height (clim-shared::graft-height-pixel graft))))))
  -   (:clim-1.0
  -    (multiple-value-bind (w h) (clim:window-inside-size frame-manager)
  -      (setq width (min width w)
  -	    height (min height h))))
  -   (:clim-2
  -    (let ((graft (clim:graft (port frame-manager))))
  -      (when graft
  -	(setq width (min width (clim:graft-width graft :units :device))
  -	      height (min height (clim:graft-height graft :units :device)))))))
  +  (let ((graft (clim:graft (port frame-manager))))
  +    (when graft
  +      (setq width (min width (clim:graft-width graft :units :device))
  +            height (min height (clim:graft-height graft :units :device)))))
     (values width height))
   
   (defun launch-frame 
  
positive.code: 			      (wait-until-done t)
  			      master
  			      (backing-store *enable-backing-store*))
    #FEATURE-CASE
    ((:clim-0.9
      (progn
        ;; If these are X windows, enable backing-store.
        #+xlib
        (let* ((pane (clim:frame-pane frame))
  	     (port (clim:port pane)))
  	(when (typep* port 'on-x::x-port)
  	  (setf (xlib:window-backing-store (w::sheet-mirror! pane))
  	    backing-store)))    
        (cond (master
  	     ;; Change the event queue and reinitialize.
  	     ;; How should this be undone if this frame is recycled?
  	     (setf (slot-value frame 'ws::queue) (ws::frame-queue master))
  	     (ci::initialize-stream-queues frame)
  	     (clim:enable-frame frame)
  	     (clim:panes-need-redisplay frame)
  	     (clim:redisplay-frame-panes frame))
  	    (t (clim:start-frame frame wait-until-done)))))
     (:clim-1.0
      (labels ((set-backing-store (window value)
  	       #+xlib
  	       (setf (xlib:window-backing-store (slot-value window 'clim::window))
  		 value)
  	       (dolist (child (slot-value window 'clim::children))
  		 (set-backing-store child value))))
        (cond (master
  	     (let ((b (clim:stream-input-buffer
  		       (clim:frame-top-level-window master)))
  		   (top-level-window (clim:frame-top-level-window frame)))
  	       (labels ((set-input-buffer (window buffer)
  			  (setf (clim:stream-input-buffer window) buffer)
  			  (dolist (w (clim:window-children window))
  			    (set-input-buffer w buffer))))
  		 (set-input-buffer top-level-window b)
  		 (set-backing-store (clim:frame-top-level-window frame)
  				    backing-store)
  		 (clim:window-expose top-level-window)
  		 (clim:redisplay-frame-panes frame :force-p t)
  		 ;; return the window just created
  		 (values top-level-window))))
  	    ((not wait-until-done)
  	     (process-run-function
  	      "Frame Top Level"
  	      'start-frame frame
  	      :wait-until-done t
  	      :master nil
  	      :backing-store backing-store)
  	     frame)
  	    (T
  	     (push (list frame (current-process)) *activated-frames*)
  	     (setq *deactivated-frames* (delete frame *deactivated-frames*))
  	     #+xlib
  	     (let ((xwin (slot-value (clim:frame-top-level-window frame) 'clim::window)))
  	       (xlib:set-wm-class xwin "clim" "clim"))
  	     (set-backing-store (clim:frame-top-level-window frame)
  				backing-store)
  	     (unwind-protect
  		 (let ((clim::*frame-layout-changing-p* t)) ; forces redisplay
  		   (clim:run-frame-top-level frame))
  	       (deactivate-frame frame))))))
     (:clim-2
      (cond (master
  	   (let ((b (clim:stream-input-buffer
  		     (clim:frame-top-level-sheet master)))
  		 (top-level-window (clim:frame-top-level-sheet frame)))
  
negative.code: 
  (defmethod reset-frame (frame &key title)
    "Prepare a frame for reuse."
    (setf (clim:frame-pretty-name frame) title)
  	      (clim:reset-frame frame))
  
  ;;; You pay a price for this, so set it to nil if resources are scarce.
  (defvar *enable-backing-store* :when-mapped
  