anchor.diff:      (let* ((aspect 1.0)
              (corner-radius (/ h 5))
              (radius (/ corner-radius aspect)))
  -      
  +
         (apply #'clear-cairo-context background)
         (clinch:draw-rounded-rectangle  w h
  -			       :line-width line-width
  -			       :line line
  -			       :fill fill)
  +                                      :line-width line-width
  +                                      :line line
  +                                      :fill fill)
   
         (apply #'cairo:set-source-rgba foreground)
         (cairo:move-to 0 (/ h 3))
  
positive.code: 
    (let ((ret))
      (maphash (lambda (k v)
  	       (push (funcall f k v) ret))
  	     (gethash e *event-hash*))
      ret))
  
  (clinch:defevent clinch:*on-mouse-down* (win mouse x y button state clicks ts)
  
negative.code: 
  
  ;; a = (sb-cga:vec* button-end-position entity-distance)
  ;; b-pos & b = buttons start and end
  ;; d-pos and d-hat = screen position and direction
  
  (defun get-translation-from-matrix (m)
    (subseq (m4:get-column m 3) 0 3))
  
  (defun rejection (a b)
    (let ((n (v3:normalize a)))
      (v3:- b (v3:*s n (v:dot n b)))))
  
  ;;(multiple-value-bind (d-pos d) (clinch:get-screen-direction (sb-cga:inverse-matrix lens))
  (defun normalized-vector-match (n v)
    (v3:length 
     (v3:/ v n)))
  
  (defun calc2 (start-pos screen-direction screen-position)
    (let ((scale (- (abs (v3:dot start-pos screen-direction))
  		  (abs (v3:dot screen-position screen-direction)))))
      (v3:*s screen-direction scale)))
  
  (defun calculate-movement (d-pos d-hat a-pos a b-pos b)
    (let ((a-rel (v3:- a-pos d-pos))
          (b-rel (v3:- b-pos d-pos)))
      (v3:-
       (v3:+ b-rel
             (v3:*s b
                    ;; find 'x'
                    (/ (v3:dot (v3:- (v3:+ a-rel a)
                                     b-rel)
                               d-hat)
                       (v3:dot b d-hat))))
       (v3:+ a-rel a))))
  
  
  ;; Idea...
  ;; Start = original vector
  ;; Current = current vector
  (defun calculate-movement2 (start end)
    (v3:- end
          (v3:*s start (v3:dot start end))))
  
  
  ;; (if (eql mouse-state :dragging)
  
  ;;     (multiple-value-bind (d-pos d) (clinch:get-screen-direction (sb-cga:inverse-matrix lens))
  ;;       (let ((trans (calculate-movement d-pos d a-pos a button-start-position button-end-position)))
  
  ;;      (map nil (lambda (node start-pos)
  ;;                 (setf (clinch:transform node)
  ;;                       (sb-cga:matrix* (sb-cga:translate (clinch:make-vector (elt trans 0) (elt trans 1) (elt trans 2)))
  ;;                                       start-pos)))
  ;;           (elt mouse-drag-values 5) mouse-drag-nodes-start-pos)))
  