anchor.diff:                          *screen-backbuffer* c-row c-col))))
   
   (defun recompose-windows (&optional full)
  -  (when (and (not full)
  -             (or (zerop *clip-rect-width*)
  -                 (zerop *clip-rect-height*)))
  +  (when full
  +    ;; Expand the cliprect to the entire screen.
  +    (setf *clip-rect-width* (mezzanine.supervisor:framebuffer-width *main-screen*)
  +          *clip-rect-height* (mezzanine.supervisor:framebuffer-height *main-screen*)
  +          *clip-rect-x* 0
  +          *clip-rect-y* 0))
  +  (when (or (zerop *clip-rect-width*)
  +                 (zerop *clip-rect-height*))
       (return-from recompose-windows))
     ;; Draw windows back-to-front.
     (dolist (window (reverse *window-list*))
  -    (if full
  -        (bitblt-argb-xrgb (height window) (width window)
  -                          (window-buffer window) 0 0
  -                          *screen-backbuffer* (window-y window) (window-x window))
  -        (blit-with-clip (height window) (width window)
  -                        (window-buffer window)
  -                        (window-y window) (window-x window))))
  +    (blit-with-clip (height window) (width window)
  +                    (window-buffer window)
  +                    (window-y window) (window-x window)))
     ;; Then the mouse pointer on top.
  -  (if full
  -      (bitblt-argb-xrgb (array-dimension *mouse-pointer* 0) (array-dimension *mouse-pointer* 1)
  -                        *mouse-pointer* 0 0
  -                        *screen-backbuffer* (- *mouse-y* *mouse-hot-y*) (- *mouse-x* *mouse-hot-x*))
  -      (blit-with-clip (array-dimension *mouse-pointer* 0) (array-dimension *mouse-pointer* 1)
  -                      *mouse-pointer*
  -                      (- *mouse-y* *mouse-hot-y*) (- *mouse-x* *mouse-hot-x*)))
  +  (blit-with-clip (array-dimension *mouse-pointer* 0) (array-dimension *mouse-pointer* 1)
  +                  *mouse-pointer*
  +                  (- *mouse-y* *mouse-hot-y*) (- *mouse-x* *mouse-hot-x*))
     ;; Update the actual screen.
  -  (if full
  -      (mezzanine.supervisor:framebuffer-blit *main-screen*
  -                                             (mezzanine.supervisor:framebuffer-height *main-screen*)
  -                                             (mezzanine.supervisor:framebuffer-width *main-screen*)
  -                                             *screen-backbuffer* 0 0
  -                                             0 0)
  -      (mezzanine.supervisor:framebuffer-blit *main-screen*
  -                                             *clip-rect-height*
  -                                             *clip-rect-width*
  -                                             *screen-backbuffer* *clip-rect-y* *clip-rect-x*
  -                                             *clip-rect-y* *clip-rect-x*))
  +  (mezzanine.supervisor:framebuffer-blit *main-screen*
  +                                         *clip-rect-height*
  +                                         *clip-rect-width*
  +                                         *screen-backbuffer* *clip-rect-y* *clip-rect-x*
  +                                         *clip-rect-y* *clip-rect-x*)
     ;; Reset clip region.
     (setf *clip-rect-x* 0
           *clip-rect-y* 0
  
positive.code: 
  (defmethod process-event ((event window-close-event))
    (format t "Closing window ~S. Goodbye!~%" (window event))
    (when (eql *active-window* (window event))
      (setf *active-window* nil))
    (setf *window-list* (remove (window event) *window-list*))
    (send-event (window event) event))
  
  (defun close-window (window)
  
negative.code:     (setf (window-x win) 0
            (window-y win) 0)
      (push win *window-list*)
      (when *active-window*
        (send-event *active-window* (make-instance 'window-activation-event
                                                   :window *active-window*
                                                   :state nil)))
      (setf *active-window* win)
      (send-event win (make-instance 'window-activation-event
                                     :window win
                                     :state t))))
  
  (defun make-window (fifo width height)
    (let ((window (make-instance 'window
  