anchor.diff:      (setf *mouse-buttons* buttons)
       ;; Dispatch events and stuff...
       ;; Raise windows when clicked on, deal with drag, etc.
  +    (when (and (not (logbitp 0 buttons))
  +               (logbitp 0 changes))
  +      ;; On left click release, select window.
  +      (let ((win (window-at-point *mouse-x* *mouse-y*)))
  +        (when (and win (not (eql win *active-window*)))
  +          (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))
  +          (setf *window-list* (remove win *window-list*))
  +          (push win *window-list*)
  +          ;; Layering change, redraw everything.
  +          ;; fixme: don't be lazy. set the cliprect properly.
  +          (setf *main-screen* nil))))
       #+(or)(do-something)
       (when (or (not (zerop x-motion))
                 (not (zerop y-motion)))
  
positive.code:                         *screen-backbuffer* c-row c-col))))
  
  (defun recompose-windows (&optional full)
    (when (and (not full)
               (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))))
    ;; 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*)))
    ;; 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*))
    ;; Reset clip region.
    (setf *clip-rect-x* 0
          *clip-rect-y* 0
  
negative.code: 
  (defmethod process-event ((event window-close-event))
    (format t "Closing window ~S. Goodbye!~%" (window event))
    (setf *window-list* (remove (window event) *window-list*))
    (when (eql *active-window* (window event))
      (setf *active-window* (first *window-list*))
      (when *active-window*
        (send-event *active-window* (make-instance 'window-activation-event
                                                   :window *active-window*
                                                   :state t))))
    (send-event (window event) event))
  
  (defun close-window (window)
  