anchor.diff:  (defconstant +roman-face-style+ (make-text-style nil :roman nil)
     "A text style specifying a roman face, but with unspecified
   family and size.")
  +
  +(defun analyse-stroke-string (string)
  +  "Return a list of parts of `string', where each part is a continuous
  +run of graphic characters or a single non-graphic character. Each element
  +in the list is of the form START, END, and one of NIL (meaning a run
  +of graphic characters) or an object representing the non-graphic char."
  +  (loop with len = (length string)
  +	for left = 0 then (+ right 1)
  +	for right = (or (position-if-not #'graphic-char-p string :start left)
  +			len)
  +	unless (= left right)
  +	  collect (list left right)
  +	  into parts
  +	until (>= right len)
  +	collect (list right 
  +		      (+ right 1) 
  +		      (non-graphic-char-rep (aref string right)))
  +	  into parts
  +	finally (return parts)))
  +
  +(defun non-graphic-char-rep (object)
  +  "Return the appropriate representation of `object', a non-graphic char.
  +This will be a string of the format \"^[letter]\" for non-graphic chars
  +with a char-code of less than #o200, \"\\[octal code]\" for those above
  +#o200, and the #\\Tab character in the case of a #\\Tab.
  +NOTE: Assumes an ASCII/Unicode character encoding."
  +  (let ((code (char-code object)))
  +    (cond ((eql object #\Tab)
  +	   object)
  +	  ((< code #o200)
  +	   (format nil "^~C" (code-char (+ code (char-code #\@)))))
  +	  (t
  +	   (format nil "\\~O" code)))))
   
   (defun stroke-drawing-fn (stream view stroke cursor-x cursor-y)
     "Draw `stroke' to `stream' at the position (`cursor-x',
  
positive.code: expects its stroke to cover a single-object non-character buffer
  region, which will be presented with its appropriate presentation
  type (found via `presentation-type-of') to generate output."
    (let (output-record)
      #'(lambda (stream view stroke cursor-x cursor-y
                 default-drawing-fn)
          (declare (ignore default-drawing-fn))
  
negative.code:   "Calculate the position in device units of `offset' in
  `stroke', relative to the starting position of `stroke'. `Offset'
  is an absolute offset into the buffer of `view',"
    (let ((string (in-place-buffer-substring
  		 (buffer view) (cache-string view)
  		 (stroke-start-offset stroke) offset)))
      (loop with pos = (- offset (stroke-start-offset stroke))
  	  for width across (stroke-widths stroke)
  	  for next upfrom 1
  	  for (start end object) in (stroke-parts stroke)
  	  when (and object (= pos end))
  	    do (return (aref (stroke-widths stroke) next))
  	  when (<= start pos end)
  	    do (return (+ width
  			  (text-size stream string
  				     :start start
  				     :end pos
  				     :text-style (merge-text-styles
  						  (face-style
  						   (drawing-options-face
  						    (stroke-drawing-options stroke)))
  						  (medium-merged-text-style (sheet-medium stream)))))))))
  
  (defgeneric offset-to-screen-position (pane view offset)
    (:documentation "Returns the position of offset as a screen
  