anchor.diff:  (defstruct (screen (:constructor %make-screen))
     view
     use-modeline
  +  modeline-elements
     x
     y
     left-lines
  
positive.code:                  (interface-clear-eob *implementation* (screen-view screen) 0 y)
                   (return))))))
  
  (defun screen-redraw-modeline (window)
    (let* ((screen (window-screen window))
           (view (screen-view screen))
           (default-attribute (if (eq window (current-window))
                                  'modeline
                                  'modeline-inactive))
           (left-x 0)
           (right-x (window-width window)))
      (interface-print-modeline *implementation* view 0 0
                                (make-string (window-width window)
                                             :initial-element #\space)
                                default-attribute)
      (modeline-apply window
                      (lambda (string attribute alignment)
                        (case alignment
                          ((:right)
                           (decf right-x (length string))
                           (interface-print-modeline *implementation*
                                                     view right-x 0 string attribute))
                          (otherwise
                           (interface-print-modeline *implementation*
                                                     view left-x 0 string attribute)
                           (incf left-x (length string)))))
                      default-attribute)))
  
  (defun redraw-display-window (window force)
    (let ((focus-window-p (eq window (current-window)))
  
negative.code:                               (if focus-window-p
                                    (count-lines (window-view-point window)
                                                 (lem::window-point window))
                                    -1))
          (setf (screen-old-left-width screen)
                (screen-left-width screen))
          (setf (screen-last-buffer-name screen)
                (buffer-name buffer))
          (setf (screen-last-buffer-modified-tick screen)
                (buffer-modified-tick buffer))
          (when (window-use-modeline-p window)
            (screen-redraw-modeline window force))
          (interface-redraw-view-after *implementation* (screen-view screen) focus-window-p)
          (setf (screen-modified-p screen) nil)))))
  
  