* The "-in-new-screen" commands have been replaced with

  "-other-screen" commands.  This is more analogous to the
  "-other-window" commands.

* New editor variable `use-multiple-screens', if set true, causes
  various window commands to use multiple screens instead of multiple
  windows.  Affected commands include C-x o, C-M-v, C-x 4, and
  commands that pop-up buffers.  This needs more work but is an
  interesting first cut.

* With multiple X screens, the selected screen is distinguished by
  having a cursor -- a screen's cursor is erased when it is
  deselected.  This is desirable because it is no longer the case that
  the selected screen and the focus screen are always the same.

* Modeline formats have been extended to allow procedures as elements.
  Such a procedure is called with the modeline's window as an
  argument, and is expected to produce another modeline-format element
  which is used in its place.

* Selecting a window in a screen other than the selected screen will
  also select that screen.

* New procedure `other-screen' will choose a different screen if one
  is available.

* New screen operations `screen-scroll-lines-down!' and
  `screen-scroll-lines-up!' return a flag saying whether they
  performed the scrolling.  Redisplay code tries to use them when it
  scrolls, and repaints if they don't work.  Currently these
  operations are implemented for X screens but not for curses.

* The `screen-write-substrings!' operation is now written in terms of
  the `screen-write-substring!' operation, so that it need not be
  implemented separately for each screen abstraction.

* The display-type abstraction has been redesigned so that it has no
  internal state -- the current display type is now part of the editor
  structure.  Most of the operations have been renamed.  The procedure
  `editor-display-type' has been eliminated, the procedure
  `editor-display-types' now returns display-type objects rather than
  their names.

* Each display-type now indicates whether it supports multiple
  screens.  This information is returned by procedure
  `multiple-screens?'.

* The buffer that appears in the typein window when no typein is
  occurring is now different than the level-0 typein buffer.  This
  means that, under normal circumstances, only one typein window shows
  the typein buffer when typein is occurring.  The previous method of
  obscuring the typein buffer with an override message on non-selected
  screens is no longer used.

* The file "winmis" has been eliminated.

* The procedure `using-screen' has been eliminated.

diff --git a/v7/src/edwin/bufcom.scm b/v7/src/edwin/bufcom.scm
index 3a7be88526152d3d1fb86280585e3ce7061db587..4cd7934de264a64fc1cf0f718347b71577a3df69 100644 (file)
--- a/v7/src/edwin/bufcom.scm
+++ b/v7/src/edwin/bufcom.scm
@@ -1,6 +1,6 @@
 ;;; -*-Scheme-*-
 ;;;
-;;;    $Header: /Users/cph/tmp/foo/mit-scheme/mit-scheme/v7/src/edwin/bufcom.scm,v 1.85 1990/10/03 04:54:03 cph Exp $
+;;;    $Header: /Users/cph/tmp/foo/mit-scheme/mit-scheme/v7/src/edwin/bufcom.scm,v 1.86 1990/10/09 16:23:12 cph Rel $
 ;;;
 ;;;    Copyright (c) 1986, 1989, 1990 Massachusetts Institute of Technology
 ;;;
@@ -74,11 +74,11 @@ specifying a non-existent buffer will cause it to be created."
   (lambda (buffer)
     (select-buffer (find-buffer buffer))))
 
-(define-command switch-to-buffer-in-new-screen
-  "Select buffer in a new screen."
-  (prompt-for-select-buffer "Switch to buffer in new screen")
+(define-command switch-to-buffer-other-screen
+  "Select buffer in another screen."
+  (prompt-for-select-buffer "Switch to buffer in other screen")
   (lambda (buffer)
-    (select-buffer-in-new-screen (find-buffer buffer))))
+    (select-buffer-other-screen (find-buffer buffer))))
 
 (define-command switch-to-buffer-other-window
   "Select buffer in another window."
@@ -92,11 +92,11 @@ specifying a non-existent buffer will cause it to be created."
   (lambda (name)
     (select-buffer (new-buffer name))))
 
-(define-command create-buffer-in-new-screen
-  "Create a new buffer with a given name, and select it in a new screen."
-  "sCreate buffer in new screen"
+(define-command create-buffer-other-screen
+  "Create a new buffer with a given name, and select it in another screen."
+  "sCreate buffer in other screen"
   (lambda (name)
-    (select-buffer-in-new-screen (new-buffer name))))
+    (select-buffer-other-screen (new-buffer name))))
 
 (define-command insert-buffer
   "Insert the contents of a specified buffer at point."

diff --git a/v7/src/edwin/curren.scm b/v7/src/edwin/curren.scm
index c029a8603b866669176aea334c83c5086145c2e3..9132c624cca65e2bf86e344ce31e8a939854ae2c 100644 (file)
--- a/v7/src/edwin/curren.scm
+++ b/v7/src/edwin/curren.scm
@@ -1,6 +1,6 @@
 ;;; -*-Scheme-*-
 ;;;
-;;;    $Header: /Users/cph/tmp/foo/mit-scheme/mit-scheme/v7/src/edwin/curren.scm,v 1.89 1990/10/06 00:15:33 cph Exp $
+;;;    $Header: /Users/cph/tmp/foo/mit-scheme/mit-scheme/v7/src/edwin/curren.scm,v 1.90 1990/10/09 16:23:40 cph Rel $
 ;;;
 ;;;    Copyright (c) 1986, 1989, 1990 Massachusetts Institute of Technology
 ;;;
@@ -48,47 +48,76 @@
 \f
 ;;;; Screens
 
-(define (make-screen buffer)
-  (without-interrupts
-   (lambda ()
-     (let ((screen (make-editor-screen)))
-       (initialize-screen-root-window! screen (current-bufferset) buffer)
-       (editor-add-screen! current-editor screen)
-       (update-screen! screen false)
-       screen))))
+(define-integrable (screen-list)
+  (editor-screens current-editor))
+
+(define-integrable (selected-screen)
+  (editor-selected-screen current-editor))
+
+(define-integrable (selected-screen? screen)
+  (eq? screen (selected-screen)))
+
+(define-integrable (multiple-screens?)
+  (display-type/multiple-screens? (current-display-type)))
+
+(define (make-screen buffer . make-screen-args)
+  (let ((display-type (current-display-type)))
+    (if (not (display-type/multiple-screens? display-type))
+       (error "display doesn't support multiple screens" display-type))
+    (without-interrupts
+     (lambda ()
+       (let ((screen (display-type/make-screen display-type make-screen-args)))
+        (initialize-screen-root-window! screen
+                                        (editor-bufferset current-editor)
+                                        buffer)
+        (set-editor-screens! current-editor
+                             (append! (editor-screens current-editor)
+                                      (list screen)))
+        (update-screen! screen false)
+        screen)))))
 
 (define (delete-screen! screen)
-  (editor-delete-screen! current-editor screen)
-  (screen-discard! screen))
+  (without-interrupts
+   (lambda ()
+     (if (selected-screen? screen)
+        (let ((screen* (other-screen screen)))
+          (if (not screen*)
+              (error "can't delete only screen" screen))
+          (select-screen screen*)))
+     (screen-discard! screen)
+     (set-editor-screens! current-editor
+                         (delq! screen
+                                (editor-screens current-editor))))))
 
 (define (select-screen screen)
   (without-interrupts
    (lambda ()
      (let ((message (current-message)))
-       (set-current-message! "")
+       (clear-current-message!)
+       (screen-exit! (selected-screen))
        (change-selected-buffer
        (window-buffer (screen-selected-window screen))
        true
        (lambda ()
          (set-editor-selected-screen! current-editor screen)))
-       (set-current-message! message)))))
-
-(define (select-buffer-in-new-screen buffer)
-  (select-screen (make-screen buffer)))
-
+       (set-current-message! message)
+       (screen-enter! screen)))))
+\f
 (define (update-screens! display-style)
-  (let loop ((screens (screen-list)))
-    (or (null? screens)
-       (and (not (screen-in-update? (car screens)))
-            (update-screen! (car screens) display-style)
-            (loop (cdr screens))))))
+  (if display-style
+      (let loop ((screens (screen-list)))
+       (or (null? screens)
+           (and (update-screen! (car screens) display-style)
+                (loop (cdr screens)))))
+      (let loop ((screens (cons (selected-screen) (screen-list))))
+       (or (null? screens)
+           (and (or (screen-in-update? (car screens))
+                    (update-screen! (car screens) false))
+                (loop (cdr screens)))))))
 
 (define (update-selected-screen! display-style)
   (update-screen! (selected-screen) display-style))
 
-(define-integrable (selected-screen? screen)
-  (eq? screen (selected-screen)))
-
 (define-integrable (screen0)
   (car (screen-list)))
 
@@ -125,6 +154,11 @@
               (loop (1+ n) (screen-1+ screen)))))
        (else
         screen)))
+
+(define (other-screen screen)
+  (let ((screen* (screen1+ screen)))
+    (and (not (eq? screen screen*))
+        screen*)))
 \f
 ;;;; Windows
 
@@ -148,7 +182,9 @@
           (change-selected-buffer (window-buffer window) true
             (lambda ()
               (screen-select-window! screen window)))
-          (screen-select-window! screen window))))))
+          (begin
+            (screen-select-window! screen window)
+            (select-screen screen)))))))
 
 (define-integrable (select-cursor window)
   (screen-select-cursor! (window-screen window) window))
@@ -321,18 +357,6 @@ The buffer is guaranteed to be selected at that time."
                          (set-window-buffer! window old-buffer true)))
                    (set! old-buffer)
                    unspecific))))
-
-(define (select-buffer-other-window buffer)
-  (let ((window
-        (let ((window (current-window)))
-          (if (window-has-no-neighbors? window)
-              (window-split-vertically! window false)
-              (or (list-search-negative (buffer-windows buffer)
-                    (lambda (window*)
-                      (eq? window window*)))
-                  (window1+ window))))))
-    (select-window window)
-    (set-window-buffer! window buffer true)))
 \f
 ;;;; Point