Index: /branches/event-ide/ccl/cocoa-ide/cocoa-editor.lisp
===================================================================
--- /branches/event-ide/ccl/cocoa-ide/cocoa-editor.lisp	(revision 7861)
+++ /branches/event-ide/ccl/cocoa-ide/cocoa-editor.lisp	(revision 7862)
@@ -28,9 +28,14 @@
 
 
-(defgeneric hi:hemlock-view (ns-object))
-
-(defmethod hi:hemlock-view ((unknown t)) nil)
-
-
+(defgeneric hemlock-view (ns-object))
+
+(defmethod hemlock-view ((unknown t))
+  nil)
+
+(defgeneric hemlock-buffer (ns-object))
+
+(defmethod hemlock-buffer ((unknown t))
+  (let ((view (hemlock-view unknown)))
+    (when view (hi::hemlock-view-buffer view))))
 
 (defmacro nsstring-encoding-to-nsinteger (n)
@@ -200,4 +205,9 @@
   (:metaclass ns:+ns-object))
 
+(defmethod hemlock-buffer ((self hemlock-buffer-string))
+  (let ((cache (hemlock-buffer-string-cache self)))
+    (when cache
+      (hemlock-buffer cache))))
+
 ;;; Cocoa wants to treat the buffer as a linear array of characters;
 ;;; Hemlock wants to treat it as a doubly-linked list of lines, so
@@ -220,4 +230,7 @@
   workline-start-font-index		; current font index at start of workline
   )
+
+(defmethod hemlock-buffer ((self buffer-cache))
+  (buffer-cache-buffer self))
 
 ;;; Initialize (or reinitialize) a buffer cache, so that it points
@@ -433,4 +446,8 @@
 (declaim (special hemlock-text-storage))
 
+(defmethod hemlock-buffer ((self hemlock-text-storage))
+  (let ((string (slot-value self 'hemlock-string)))
+    (unless (%null-ptr-p string)
+      (hemlock-buffer string))))
 
 ;;; This is only here so that calls to it can be logged for debugging.
@@ -475,5 +492,5 @@
   (assume-cocoa-thread)
   (let* ((mirror (#/mirror self))
-         (hemlock-string (#/hemlockString self))
+	 (hemlock-string (#/hemlockString self))
          (display (hemlock-buffer-string-cache hemlock-string))
          (buffer (buffer-cache-buffer display))
@@ -686,41 +703,34 @@
 (objc:defmethod (#/replaceCharactersInRange:withString: :void)
     ((self hemlock-text-storage) (r :<NSR>ange) string)
-  #+debug (#_NSLog #@"Replace in range %ld/%ld with %@"
-                    :<NSI>nteger (pref r :<NSR>ange.location)
-                    :<NSI>nteger (pref r :<NSR>ange.length)
-                    :id string)
-  (let* ((cache (hemlock-buffer-string-cache (#/hemlockString  self)))
-	 (buffer (if cache (buffer-cache-buffer cache)))
-	 (hi::*current-buffer* buffer)
-         (location (pref r :<NSR>ange.location))
+  #+GZ (log-debug "~&replaceCharacters ts: ~s r: ~s s: ~s buf ~s frame: ~s"
+		   self r string (hemlock-buffer self) (find (hemlock-buffer self) (windows) :key #'hemlock-buffer))
+  (let* ((buffer (hemlock-buffer self))
+         (position (pref r :<NSR>ange.location))
 	 (length (pref r :<NSR>ange.length))
-	 (point (hi::buffer-point buffer)))
-    (let* ((lisp-string (if (> (#/length string) 0) (lisp-string-from-nsstring string)))
-           (document (if buffer (hi::buffer-document buffer)))
-           (textstorage (if document (slot-value document 'textstorage))))
-      #+gz (unless (eql textstorage self) (break "why is self.ne.textstorage?"))
-      (when textstorage
-	(assume-cocoa-thread)
-	(#/beginEditing textstorage))
-      (setf (hi::buffer-region-active buffer) nil)
-      (hi::with-mark ((start point :right-inserting))
-        (move-hemlock-mark-to-absolute-position start cache location)
-        (unless (zerop length)
-          (hi::delete-characters start length))
-        (when lisp-string
-          (hi::insert-string start lisp-string)))
-      (when textstorage
-        (#/endEditing textstorage)
-	;; This isn't really right.  It should abort the entire command in progress,
-	;; e.g. c-x ..., etc. and should do it before event start... Basically it
-	;; should be handled as if it was a regular key event, except for the
-	;; extra string argument.
-        (for-each-textview-using-storage
-         textstorage
-         (lambda (tv)
-           (hi::disable-self-insert
-	    (hi:hemlock-view tv))))
-        (#/ensureSelectionVisible textstorage)))))
-
+	 (lisp-string (if (> (#/length string) 0) (lisp-string-from-nsstring string)))
+	 ;; In theory (though not yet in practice) we allow for a buffer to be shown in multiple
+	 ;; windows, and this change has to affect all the windows.  That's true for all changes
+	 ;; to a buffer, so once hemlock supports multiple views of a buffer, it will have some
+	 ;; way to update all the views.  So just pick any one window here and let hemlock take
+	 ;; care of the rest.
+	 (view (loop for w in (windows) thereis (and (eq (hemlock-buffer w) buffer) (hemlock-view w)))))
+    (when view
+      (hi::handle-hemlock-event view #'(lambda ()
+					 (hi:paste-characters position length
+							      lisp-string)))
+      )))
+
+#|
+TODO: the absolute-bla bla stuff is likely not used anymore, right?
+
+;; TODO: If selection scrolled out of view, anything that modifies the buffer should
+;; bring the selection back into view so the user can see what happened.
+;; Hemlock should ensure that.
+(defmethod ensure-selection-visible ((view hi:hemlock-view))
+  (let ((tv ???))
+  (assume-not-editing tv)
+  (#/scrollRangeToVisible: tv (#/selectedRange tv))
+  ))
+|#
 
 (objc:defmethod (#/setAttributes:range: :void) ((self hemlock-text-storage)
@@ -749,14 +759,4 @@
 (objc:defmethod #/description ((self hemlock-text-storage))
   (#/stringWithFormat: ns:ns-string #@"%s : string %@" (#_object_getClassName self) (slot-value self 'hemlock-string)))
-
-;;; This needs to happen on the main thread.
-(objc:defmethod (#/ensureSelectionVisible :void) ((self hemlock-text-storage))
-  (assume-cocoa-thread)
-  (for-each-textview-using-storage
-   self
-   #'(lambda (tv)
-       (assume-not-editing tv)
-       (#/scrollRangeToVisible: tv (#/selectedRange tv)))))
-
 
 (defun close-hemlock-textstorage (ts)
@@ -811,14 +811,23 @@
 (declaim (special hemlock-textstorage-text-view))
 
-(defmethod hi:hemlock-view ((self hemlock-textstorage-text-view))
-  ;; Not sure when any of this can fail, but at least try to make sure that if hemlock-view
-  ;; returns non-nil, then callers don't have to check for any other marginal situations.
+(defmethod hemlock-view ((self hemlock-textstorage-text-view))
   (let ((frame (#/window self)))
     (unless (%null-ptr-p frame)
-      (let ((view (hi:hemlock-view frame)))
-	(when view
-	  (when (eq (hi::hemlock-view-buffer view) (text-view-buffer self))
-	    view))))))
-
+      (hemlock-view frame))))
+
+(defmethod activate-hemlock-view ((self hemlock-textstorage-text-view))
+  (assume-cocoa-thread)
+  (let* ((the-hemlock-frame (#/window self)))
+    #+debug (log-debug "Activating ~s" self)
+    (with-slots ((echo peer)) self
+      (deactivate-hemlock-view echo))
+    (#/setEditable: self t)
+    (#/makeFirstResponder: the-hemlock-frame self)))
+
+(defmethod deactivate-hemlock-view ((self hemlock-textstorage-text-view))
+  (assume-cocoa-thread)
+  #+debug (log-debug "deactivating ~s" self)
+  (assume-not-editing self)
+  (#/setSelectable: self nil))
 
 (defmethod eventqueue-abort-pending-p ((self hemlock-textstorage-text-view))
@@ -840,5 +849,5 @@
 (objc:defmethod (#/keyDown: :void) ((self hemlock-textstorage-text-view) event)
   #+debug (#_NSLog #@"Key down event = %@" :address event)
-  (let* ((view (hi:hemlock-view self))
+  (let* ((view (hemlock-view self))
 	 ;; quote-p means handle characters natively
 	 (quote-p (and view (hi::hemlock-view-quote-next-p view))))
@@ -896,5 +905,5 @@
   ;; If no modifier keys are pressed, send hemlock a no-op.
   (unless (logtest #$NSDeviceIndependentModifierFlagsMask (#/modifierFlags event))
-    (let* ((view (hi:hemlock-view self)))
+    (let* ((view (hemlock-view self)))
       (when view
 	(unless (eventqueue-abort-pending-p self)
@@ -989,6 +998,5 @@
 (defmethod update-blink ((self hemlock-textstorage-text-view))
   (disable-blink self)
-  (let* ((d (hemlock-buffer-string-cache (#/hemlockString (#/textStorage self))))
-         (buffer (buffer-cache-buffer d)))
+  (let* ((buffer (hemlock-buffer self)))
     (when (and buffer (string= (hi::buffer-major-mode buffer) "Lisp"))
       (let* ((hi::*current-buffer* buffer)
@@ -1063,4 +1071,9 @@
      (char-height :foreign-type :<CGF>loat :accessor text-view-char-height))
   (:metaclass ns:+ns-object))
+(declaim (special hemlock-text-view))
+
+(defmethod hemlock-view ((self hemlock-text-view))
+  (let ((pane (text-view-pane self)))
+    (when pane (hemlock-view pane))))
 
 (objc:defmethod (#/evalSelection: :void) ((self hemlock-text-view) sender)
@@ -1203,11 +1216,6 @@
 
 
-
-;;; Access the underlying buffer in one swell foop.
-(defmethod text-view-buffer ((self hemlock-textstorage-text-view))
-  (buffer-cache-buffer (hemlock-buffer-string-cache (#/hemlockString (#/textStorage self)))))
-
-
-
+(defmethod text-view-string-cache ((self hemlock-textstorage-text-view))
+  (hemlock-buffer-string-cache (#/hemlockString (#/textStorage self))))
 
 (objc:defmethod (#/selectionRangeForProposedRange:granularity: :ns-range)
@@ -1398,5 +1406,5 @@
       (let* ((tv (text-pane-text-view pane)))
         (unless (%null-ptr-p tv)
-	  (text-view-buffer tv))))))
+	  (hemlock-buffer tv))))))
 
 ;;; Draw a string in the modeline view.  The font and other attributes
@@ -1510,8 +1518,12 @@
 
 (defclass text-pane (ns:ns-box)
-    ((text-view :foreign-type :id :accessor text-pane-text-view)
+    ((hemlock-view :initform nil :reader text-pane-hemlock-view)
+     (text-view :foreign-type :id :accessor text-pane-text-view)
      (mode-line :foreign-type :id :accessor text-pane-mode-line)
      (scroll-view :foreign-type :id :accessor text-pane-scroll-view))
   (:metaclass ns:+ns-object))
+
+(defmethod hemlock-view ((self text-pane))
+  (text-pane-hemlock-view self))
 
 ;;; Mark the buffer's modeline as needing display.  This is called whenever
@@ -1633,61 +1645,22 @@
       tv)))
 
-
-(objc:defmethod (#/activateHemlockView :void) ((self text-pane))
-  (let* ((the-hemlock-frame (#/window self))
-	 (text-view (text-pane-text-view self)))
-    #+debug (#_NSLog #@"Activating text pane")
-    (with-slots ((echo peer)) text-view
-      (deactivate-hemlock-view echo))
-    (#/setEditable: text-view t)
-    (#/makeFirstResponder: the-hemlock-frame text-view)))
-
-(defmethod hi::activate-hemlock-view ((view text-pane))
-  (#/performSelectorOnMainThread:withObject:waitUntilDone:
-   view
-   (@selector #/activateHemlockView)
-   +null-ptr+
-   t))
-
-
-
-(defmethod deactivate-hemlock-view ((self hemlock-text-view))
-  #+debug (#_NSLog #@"deactivating text view")
-  (#/setSelectable: self nil))
+(defmethod hemlock-ext:change-active-pane ((view hi:hemlock-view) new-pane)
+  #+GZ (log-debug "change active pane, current: ~s" new-pane)
+  (let* ((pane (hi::hemlock-view-pane view))
+	 (text-view (text-pane-text-view pane))
+	 (tv (ecase new-pane
+	       (:echo (slot-value text-view 'peer))
+	       (:text text-view))))
+    (activate-hemlock-view tv)))
 
 (defclass echo-area-view (hemlock-textstorage-text-view)
     ()
   (:metaclass ns:+ns-object))
-
-(objc:defmethod (#/activateHemlockView :void) ((self echo-area-view))
-  (assume-cocoa-thread)
-  (let* ((the-hemlock-frame (#/window self)))
-    #+debug
-    (#_NSLog #@"Activating echo area")
-    (with-slots ((pane peer)) self
-      (deactivate-hemlock-view pane))
-    (#/setEditable: self t)
-  (#/makeFirstResponder: the-hemlock-frame self)))
-
-(defmethod hi::activate-hemlock-view ((view echo-area-view))
-  (#/performSelectorOnMainThread:withObject:waitUntilDone:
-   view
-   (@selector #/activateHemlockView)
-   +null-ptr+
-   t))
-
-(defmethod deactivate-hemlock-view ((self echo-area-view))
-  (assume-cocoa-thread)
-  #+debug (#_NSLog #@"deactivating echo area")
-  (let* ((ts (#/textStorage self)))
-    #+debug 0
-    (when (#/editingInProgress ts)
-      (#_NSLog #@"deactivating %@, edit-count = %d" :id self :int (slot-value ts 'edit-count)))
-    (do* ()
-         ((not (#/editingInProgress ts)))
-      (#/endEditing ts))
-
-    (#/setSelectable: self nil)))
-
+(declaim (special echo-area-view))
+
+(defmethod hemlock-view ((self echo-area-view))
+  (let ((text-view (slot-value self 'peer)))
+    (when text-view
+      (hemlock-view text-view))))
 
 ;;; The "document" for an echo-area isn't a real NSDocument.
@@ -1695,4 +1668,9 @@
     ((textstorage :foreign-type :id))
   (:metaclass ns:+ns-object))
+
+(defmethod hemlock-buffer ((self echo-area-document))
+  (let ((ts (slot-value self 'textstorage)))
+    (unless (%null-ptr-p ts)
+      (hemlock-buffer ts))))
 
 (objc:defmethod (#/undoManager :<BOOL>) ((self echo-area-document))
@@ -1788,5 +1766,4 @@
     ((echo-area-view :foreign-type :id)
      (pane :foreign-type :id)
-     (hemlock-view :initform nil :reader hemlock-frame-hemlock-view)
      (echo-area-buffer :initform nil :accessor hemlock-frame-echo-area-buffer)
      (echo-area-stream :initform nil :accessor hemlock-frame-echo-area-stream))
@@ -1794,7 +1771,8 @@
 (declaim (special hemlock-frame))
 
-(defmethod hi:hemlock-view ((self hemlock-frame))
-  (hemlock-frame-hemlock-view self))
-
+(defmethod hemlock-view ((self hemlock-frame))
+  (let ((pane (slot-value self 'pane)))
+    (unless (%null-ptr-p pane)
+      (hemlock-view pane))))
 
 (defun double-%-in (string)
@@ -1955,22 +1933,27 @@
   (assume-cocoa-thread)
   (let* ((pane (textpane-for-textstorage class ts ncols nrows container-tracks-text-view-width color style))
+         (buffer (hemlock-buffer ts))
          (frame (#/window pane))
-         (buffer (text-view-buffer (text-pane-text-view pane)))
          (echo-area (make-echo-area-for-window frame buffer color))
+	 (echo-buffer (hemlock-buffer (#/textStorage echo-area)))
          (tv (text-pane-text-view pane)))
+    #+GZ (assert echo-buffer)
     (with-slots (peer) tv
       (setq peer echo-area))
     (with-slots (peer) echo-area
       (setq peer tv))
-    (hi::activate-hemlock-view pane)
-    (setf (slot-value frame 'hemlock-view)
+    (setf (slot-value frame 'echo-area-view) echo-area
+          (slot-value frame 'pane) pane)
+    #+GZ (log-debug "~&echo-area: ~s textstorage: ~s"
+		    echo-area
+		    (#/textStorage echo-area))
+    (setf (slot-value pane 'hemlock-view)
 	  (make-instance 'hi:hemlock-view
 	    :buffer buffer
 	    :pane pane
-	    :echo-area-buffer (hemlock-frame-echo-area-buffer frame)
-	    :echo-area-pane echo-area))
-    (setf (slot-value frame 'echo-area-view) echo-area
-          (slot-value frame 'pane) pane)
-    frame))
+	    :echo-area-buffer echo-buffer))
+
+    (activate-hemlock-view tv)
+   frame))
 
 
@@ -2003,6 +1986,5 @@
 	(let ((ts (slot-value document 'textstorage)))
 	  (#/endEditing ts)
-	  ;; TODO: no reason for this to be an objC function!!
-	  (#/updateHemlockSelection ts))))))
+	  (update-hemlock-selection ts))))))
 
 (defun buffer-document-begin-editing (buffer)
@@ -2108,5 +2090,5 @@
 (defun hemlock-ext:note-buffer-saved (buffer)
   (assume-cocoa-thread)
-  (let* ((document (buffer-document buffer)))
+  (let* ((document (hi::buffer-document buffer)))
     (when document
       ;; Hmm... I guess this is always done by the act of saving.
@@ -2115,5 +2097,5 @@
 (defun hemlock-ext:note-buffer-unsaved (buffer)
   (assume-cocoa-thread)
-  (let* ((document (buffer-document buffer)))
+  (let* ((document (hi::buffer-document buffer)))
     (when document
       (#/updateChangeCount: document #$NSChangeCleared))))
@@ -2167,8 +2149,8 @@
   (:metaclass ns:+ns-object))
 
-(defmethod hi:hemlock-view ((self hemlock-editor-window-controller))
+(defmethod hemlock-view ((self hemlock-editor-window-controller))
   (let ((frame (#/window self)))
     (unless (%null-ptr-p frame)
-      (hi:hemlock-view frame))))
+      (hemlock-view frame))))
 
 ;;; Map *default-file-character-encoding* to an :<NSS>tring<E>ncoding
@@ -2205,4 +2187,9 @@
      (encoding :foreign-type :<NSS>tring<E>ncoding :initform (get-default-encoding)))
   (:metaclass ns:+ns-object))
+
+(defmethod hemlock-buffer ((self hemlock-editor-document))
+  (let ((ts (slot-value self 'textstorage)))
+    (unless (%null-ptr-p ts)
+      (hemlock-buffer ts))))
 
 (defmethod assume-not-editing ((doc hemlock-editor-document))
@@ -2256,6 +2243,5 @@
                (eql action (@selector #/compileBuffer:))
                (eql action (@selector #/compileAndLoadBuffer:))) 
-           (let* ((d (hemlock-buffer-string-cache (#/hemlockString (#/textStorage self))))
-                  (buffer (buffer-cache-buffer d))
+           (let* ((buffer (hemlock-buffer self))
                   (pathname (hi::buffer-pathname buffer)))
              (not (null pathname))))
@@ -2328,5 +2314,5 @@
     (#/updateMirror textstorage)
     (#/endEditing textstorage)
-    (#/updateHemlockSelection textstorage)
+    (update-hemlock-selection textstorage)
     (setf (hi::buffer-modified buffer) nil)
     (hi::note-modeline-change buffer)
@@ -2448,29 +2434,15 @@
 
 (defmethod hemlock-document-buffer (document)
-  (let* ((string (#/hemlockString (slot-value document 'textstorage))))
-    (unless (%null-ptr-p string)
-      (let* ((cache (hemlock-buffer-string-cache string)))
-	(when cache (buffer-cache-buffer cache))))))
-
-(defmethod hemlock-buffer ((frame hemlock-frame))
-  (let* ((dc (#/sharedDocumentController ns:ns-document-controller))
-	 (doc (#/documentForWindow: dc frame)))
-    ;; Sometimes doc is null.  Why?  What would cause a hemlock frame to
-    ;; not have a document?  (When it happened, there seemed to be a hemlock
-    ;; frame in (windows) that didn't correspond to any visible window).
-    (unless (%null-ptr-p doc)
-      (hemlock-document-buffer doc))))
-
-(defmethod hemlock-buffer ((pane text-pane))
-  (hemlock-buffer (#/window pane)))
-
-(defmethod hemlock-buffer (whatever)
-  (let ((view (hi::hemlock-view whatever)))
-    (when view (hi::hemlock-view-buffer view))))
-
-(defun hemlock-ext:visible-buffers ()
-  "List of all buffers visible in windows, in z-order, frontmost first"
+  (hemlock-buffer document))
+
+(defmethod hemlock-view ((frame hemlock-frame))
+  (let ((pane (slot-value frame 'pane)))
+    (when (and pane (not (%null-ptr-p pane)))
+      (hemlock-view pane))))
+
+(defun hemlock-ext:all-hemlock-views ()
+  "List of all hemlock views, in z-order, frontmost first"
   (loop for win in (windows)
-    as buf = (and (typep win 'hemlock-frame) (hemlock-buffer win))
+    as buf = (and (typep win 'hemlock-frame) (hemlock-view win))
     when buf collect buf))
 
@@ -2786,8 +2758,7 @@
 
 ;;; This needs to run on the main thread.
-(objc:defmethod (#/updateHemlockSelection :void) ((self hemlock-text-storage))
+(defmethod update-hemlock-selection ((self hemlock-text-storage))
   (assume-cocoa-thread)
-  (let* ((string (#/hemlockString self))
-         (buffer (buffer-cache-buffer (hemlock-buffer-string-cache string)))
+  (let* ((buffer (buffer-cache-buffer (hemlock-buffer-string-cache (#/hemlockString self))))
 	 (hi::*current-buffer* buffer)
          (point (hi::buffer-point buffer))
@@ -2921,5 +2892,5 @@
             (#/makeWindowControllers document))
           (find-definition-in-document name indicator document)
-          (#/updateHemlockSelection (slot-value document 'textstorage))
+          (update-hemlock-selection (slot-value document 'textstorage))
           (#/showWindows document))))))
 
Index: /branches/event-ide/ccl/cocoa-ide/cocoa-grep.lisp
===================================================================
--- /branches/event-ide/ccl/cocoa-ide/cocoa-grep.lisp	(revision 7861)
+++ /branches/event-ide/ccl/cocoa-ide/cocoa-grep.lisp	(revision 7862)
@@ -38,5 +38,5 @@
 	     (hi::*current-buffer* buffer))
 	(edit-grep-line-in-buffer line-num))
-      (#/updateHemlockSelection (slot-value document 'textstorage))
+      (update-hemlock-selection (slot-value document 'textstorage))
       (#/showWindows document))))
 
Index: /branches/event-ide/ccl/cocoa-ide/cocoa-listener.lisp
===================================================================
--- /branches/event-ide/ccl/cocoa-ide/cocoa-listener.lisp	(revision 7861)
+++ /branches/event-ide/ccl/cocoa-ide/cocoa-listener.lisp	(revision 7862)
@@ -202,5 +202,5 @@
                       (%get-unsigned-byte xlate (+ noctets-used i)))))
             (setq nextra n)
-	    (let ((view (hi::hemlock-view self)))
+	    (let ((view (hemlock-view self)))
 	      (queue-for-cocoa-thread #'(lambda () (append-output view string))))
             (#/readInBackgroundAndNotify fh)))))))
Index: /branches/event-ide/ccl/cocoa-ide/hemlock/src/echo.lisp
===================================================================
--- /branches/event-ide/ccl/cocoa-ide/hemlock/src/echo.lisp	(revision 7861)
+++ /branches/event-ide/ccl/cocoa-ide/hemlock/src/echo.lisp	(revision 7862)
@@ -133,7 +133,9 @@
 		  (buffer-name (hemlock-view-buffer *recursive-edit-view*))))
   (modifying-echo-buffer
-   (let* ((old-eps (hemlock-prompted-input-state *current-view*))
-	  (parse-mark (copy-mark (buffer-point *current-buffer*) :right-inserting))
-	  (end-mark (buffer-end-mark *current-buffer*))
+   (let* ((view *current-view*)
+	  (buffer *current-buffer*)
+	  (old-eps (hemlock-prompted-input-state view))
+	  (parse-mark (copy-mark (buffer-point buffer) :right-inserting))
+	  (end-mark (buffer-end-mark buffer))
 	  (eps (make-echo-parse-state
 		:parse-starting-mark parse-mark
@@ -153,6 +155,8 @@
        (editor-error "Attempt to recursively use echo area"))
      (unwind-protect
-	 (let ((*recursive-edit-view* *current-view*))
-	   (setf (hemlock-prompted-input-state *current-view*) eps)
+	 (let ((*recursive-edit-view* view))
+	   (setf (hemlock-prompted-input-state view) eps)
+	   (unless old-eps
+	     (hemlock-ext:change-active-pane view :echo))
 	   (display-prompt-nicely eps)
 	   (modifying-buffer-storage (nil)
@@ -160,5 +164,7 @@
 	      (gui::event-loop #'(lambda () (eps-parse-results eps)))))
 	   #+gz (gui::log-debug "~&Event loop exited!, results = ~s" (eps-parse-results eps)))
-       (setf (hemlock-prompted-input-state *current-view*) old-eps)
+       (setf (hemlock-prompted-input-state view) old-eps)
+       (unless old-eps
+	 (hemlock-ext:change-active-pane view :text))
        (delete-mark parse-mark))
      (let ((results (eps-parse-results eps)))
@@ -279,5 +285,5 @@
     (cond (pn)
 	  (t (modifying-echo-buffer
-              (delete-characters (region-end (eps-input-region eps))
+              (delete-characters (region-end (eps-parse-input-region eps))
 				 (- idx (length string))))
 	     nil))))
Index: /branches/event-ide/ccl/cocoa-ide/hemlock/src/htext3.lisp
===================================================================
--- /branches/event-ide/ccl/cocoa-ide/hemlock/src/htext3.lisp	(revision 7861)
+++ /branches/event-ide/ccl/cocoa-ide/hemlock/src/htext3.lisp	(revision 7862)
@@ -272,2 +272,11 @@
           (adjust-line-origins-forward line)
           (buffer-note-insertion buffer mark nins)))))))
+
+(defun paste-characters (position count string)
+  "Replace COUNT characters at POSITION with STRING.  POSITION is the
+absolute character position in buffer"
+  (with-mark ((m (buffer-start-mark (current-buffer))))
+    (unless (character-offset m position)
+      (buffer-end m))
+    (when (> count 0) (delete-characters m count))
+    (when string (insert-string m string))))
Index: /branches/event-ide/ccl/cocoa-ide/hemlock/src/package.lisp
===================================================================
--- /branches/event-ide/ccl/cocoa-ide/hemlock/src/package.lisp	(revision 7861)
+++ /branches/event-ide/ccl/cocoa-ide/hemlock/src/package.lisp	(revision 7862)
@@ -306,4 +306,6 @@
   #+clozure
   (:import-from :ccl #:memq #:assq #:delq)
+  #+clozure
+  (:import-from :gui #:log-debug)
   ;;
   (:export
@@ -357,7 +359,8 @@
    #:note-buffer-unsaved
    #:read-only-listener-p
-   #:visible-buffers
+   #:all-hemlock-views
    #:open-sequence-dialog
    #:edit-single-definition
+   #:change-active-pane
    ))
 
@@ -394,5 +397,6 @@
    #:stream-line-column)
   (:import-from :hemlock-ext
-                #:delq #:memq #:assq)
+                #:delq #:memq #:assq
+		#+clozure #:log-debug)
   ;;
   (:export
@@ -431,5 +435,5 @@
 
    ;; from views.lisp
-   #:hemlock-view #:current-view
+   #:hemlock-view #:current-view #:hemlock-view-buffer
    #:current-prefix-argument-state #:last-key-event-typed #:last-char-typed
    #:abort-to-toplevel #:abort-current-command
@@ -519,5 +523,5 @@
    ;; htext3.lisp
    #:insert-character #:insert-string #:insert-region #:ninsert-region
-
+   #:paste-characters
 
    ;; htext4.lisp
@@ -574,6 +578,7 @@
 (defpackage :hemlock
   (:use :common-lisp :hemlock-interface :hemlock-internals :hemlock-ext)
-  (:shadowing-import-from #:hemlock-ext
+  (:shadowing-import-from :hemlock-ext
 			  #:char-code-limit)
+  #+clozure (:import-from :hemlock-ext #:log-debug)
   )
 
Index: /branches/event-ide/ccl/cocoa-ide/hemlock/src/symbol-completion.lisp
===================================================================
--- /branches/event-ide/ccl/cocoa-ide/hemlock/src/symbol-completion.lisp	(revision 7861)
+++ /branches/event-ide/ccl/cocoa-ide/hemlock/src/symbol-completion.lisp	(revision 7862)
@@ -103,5 +103,5 @@
 
 (defmethod dabbrev-sources-in ((state (eql :other-buffers)) context)
-  (let* ((buffers (hemlock-ext:visible-buffers)))
+  (let* ((buffers (mapcar #'hemlock-view-buffer (hemlock-ext:all-hemlock-views))))
     ;; Remove duplicates, always keeping the first occurance (frontmost window)
     (loop for blist on buffers do (setf (cdr blist) (delete (car blist) (cdr blist))))
Index: /branches/event-ide/ccl/cocoa-ide/hemlock/src/views.lisp
===================================================================
--- /branches/event-ide/ccl/cocoa-ide/hemlock/src/views.lisp	(revision 7861)
+++ /branches/event-ide/ccl/cocoa-ide/hemlock/src/views.lisp	(revision 7862)
@@ -30,9 +30,7 @@
 
 (defclass hemlock-view ()
-  ((buffer :initarg :buffer :reader hemlock-view-buffer)
-   (pane :initarg :pane :reader hemlock-view-pane)
+  ((pane :initarg :pane :reader hemlock-view-pane)
+   (buffer :initarg :buffer :reader hemlock-view-buffer)
    (echo-area-buffer :initarg :echo-area-buffer :reader hemlock-echo-area-buffer)
-   (echo-area-pane :initarg :echo-area-pane :reader hemlock-echo-area-pane)
-
    (echo-area-stream :reader hemlock-echo-area-stream)
 
@@ -223,11 +221,14 @@
 		  (message cstr))))))))))
 
+(defmethod hemlock-view-current-buffer ((view hemlock-view))
+  (if (hemlock-prompted-input-state view)
+    (hemlock-echo-area-buffer view)
+    (hemlock-view-buffer view)))
+
 (defmethod handle-hemlock-event ((view hemlock-view) key)
   ;; Key can also be a function, in which case it will get executed in the view event context
   (ccl::with-standard-abort-handling "Abort editor event handling"
     (let* ((*current-view* view)
-	   (*current-buffer* (if (hemlock-prompted-input-state view)
-			       (hemlock-echo-area-buffer view)
-			       (hemlock-view-buffer view))))
+	   (*current-buffer* (hemlock-view-current-buffer view)))
       (with-buffer-bindings (*current-buffer*)
 	(modifying-buffer-storage (*current-buffer*)