anchor.diff:  ;;; From Franz Users Guide
   
   (defun find-application-frame (frame-name &rest initargs
  -			       &key (create t) (activate t)
  -			       (own-process *multiprocessing-p*) port
  -			       frame-manager frame-class
  -			       &allow-other-keys)
  +                               &key (create t) (activate t)
  +                               (own-process *multiprocessing-p*) port
  +                               frame-manager frame-class
  +                               &allow-other-keys)
     (declare (ignorable frame-class))
     (let ((frame (unless (eq create :force)
  -		 (block
  -		     found-frame
  -		   (map-over-frames
  -		    #'(lambda (frame)
  -			(when (eq (frame-name frame) frame-name)
  -			  (return-from found-frame frame)))
  -		    :port port
  -		    :frame-manager frame-manager)))))
  +                 (block
  +                     found-frame
  +                   (map-over-frames
  +                    #'(lambda (frame)
  +                        (when (eq (frame-name frame) frame-name)
  +                          (return-from found-frame frame)))
  +                    :port port
  +                    :frame-manager frame-manager)))))
       (unless (or frame create)
         (return-from find-application-frame nil))
       (unless frame
         (with-keywords-removed (initargs (:create :activate :own-process))
  -	(setq frame (apply #'make-application-frame frame-name initargs))))
  +        (setq frame (apply #'make-application-frame frame-name initargs))))
       (when (and frame activate)
         (cond ((frame-process frame)
  -	     (raise-frame frame))
  -	    (own-process
  -	     (clim-sys:make-process #'(lambda ()
  -					(run-frame-top-level frame))
  -				    :name (format nil "~A" frame-name)))
  -	    (t (run-frame-top-level frame))))
  +             (raise-frame frame))
  +            (own-process
  +             (clim-sys:make-process #'(lambda ()
  +                                        (run-frame-top-level frame))
  +                                    :name (format nil "~A" frame-name)))
  +            (t (run-frame-top-level frame))))
       frame))
   
   
  
positive.code:   (let ((pane (frame-top-level-sheet frame)))
      ;(destructuring-bind (&key left top right bottom width height) (frame-geometry frame)
      (with-slots (geometry-left geometry-top geometry-right
  			       geometry-bottom geometry-width
  			       geometry-height) frame
        ;; Find width and height from looking at the respective options
        ;; first, then at left/right and top/bottom and finally at what
        ;; compose-space says.
        (let* ((width (or geometry-width
  			(and geometry-left geometry-right
  			     (- geometry-right geometry-left))
  			(space-requirement-width (compose-space pane))))
  	     (height (or geometry-height
  			 (and geometry-top geometry-bottom (- geometry-bottom geometry-top))
  			 (space-requirement-height (compose-space pane))))
  	     ;; See if a position is wanted and return left, top.
  	     (left (or geometry-left
  		       (and geometry-right (- geometry-right geometry-width))))
  	     (top (or geometry-top
  		      (and geometry-bottom (- geometry-bottom geometry-height)))))
        (values width height left top)))))
  
  ;;; This method causes related frames share the same queue by default (on both
  
negative.code: (defmethod (setf frame-command-table) :around (new-command-table frame)
    (flet ((get-menu (x) (slot-value x 'menu)))
      (if (and (get-menu (frame-command-table frame))
               (get-menu new-command-table))
          (prog1
              (call-next-method)
            (alexandria:when-let ((menu-bar-pane (frame-menu-bar-pane frame)))
                                 (update-menu-bar menu-bar-pane
                                                  new-command-table)))
          (call-next-method))))
  
  (defmethod generate-panes :before (fm  (frame application-frame))
    (declare (ignore fm))
    (when (and (frame-panes frame)
               (eq (sheet-parent (frame-panes frame))
                   (frame-top-level-sheet frame)))
      (sheet-disown-child (frame-top-level-sheet frame) (frame-panes frame)))
    (loop
       for (nil . pane) in (frame-panes-for-layout frame)
  