*** empty log message ***

3 files changed, 437 insertions, 437 deletions

diff --git a/src/window.c b/src/window.c
index 20281235dac..3b2c123a6ae 100644
--- a/src/window.c
+++ b/src/window.c
@@ -21,7 +21,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "config.h"
 #include "lisp.h"
 #include "buffer.h"
-#include "screen.h"
+#include "frame.h"
 #include "window.h"
 #include "commands.h"
 #include "indent.h"
@@ -43,11 +43,11 @@ static struct window *decode_window();
    the top level editing loop at the end of each command.
 
    This value is always the same as
-    SCREEN_SELECTED_WINDOW (selected_screen).  */
+   FRAME_SELECTED_WINDOW (selected_frame).  */
 
 Lisp_Object selected_window;
 
-/* The minibuffer window of the selected screen.
+/* The minibuffer window of the selected frame.
    Note that you cannot test for minibufferness of an arbitrary window
    by comparing against this; but you can test for minibufferness of
    the selected window.  */
@@ -76,11 +76,11 @@ int window_min_width;
 /* Nonzero implies Fdisplay_buffer should create windows. */
 int pop_up_windows;
 
-/* Nonzero implies make new X screens for Fdisplay_buffer.  */
-int pop_up_screens;
+/* Nonzero implies make new frames for Fdisplay_buffer.  */
+int pop_up_frames;
 
 /* Non-nil means use this function instead of default */
-Lisp_Object Vpop_up_screen_function;
+Lisp_Object Vpop_up_frame_function;
 
 /* Function to call to handle Fdisplay_buffer.  */
 Lisp_Object Vdisplay_buffer_function;
@@ -128,7 +128,7 @@ make_window ()
   p->start = Fmake_marker ();
   p->pointm = Fmake_marker ();
   XFASTINT (p->use_time) = 0;
-  p->screen = Qnil;
+  p->frame = Qnil;
   p->display_table = Qnil;
   p->dedicated = Qnil;
   return val;
@@ -145,9 +145,9 @@ DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 0, 0,
   "Return the window used now for minibuffers.")
   ()
 {
-#ifdef MULTI_SCREEN
-  choose_minibuf_screen ();
-#endif /* MULTI_SCREEN */
+#ifdef MULTI_FRAME
+  choose_minibuf_frame ();
+#endif /* MULTI_FRAME */
   return minibuf_window;
 }
 
@@ -162,7 +162,7 @@ DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, Swindow_minibuffer_p, 1, 1,
 
 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
   Spos_visible_in_window_p, 0, 2, 0,
-  "Return t if position POS is currently on the screen in WINDOW.\n\
+  "Return t if position POS is currently on the frame in WINDOW.\n\
 Returns nil if that position is scrolled vertically out of view.\n\
 POS defaults to point; WINDOW, to the selected window.")
   (pos, window)
@@ -198,7 +198,7 @@ POS defaults to point; WINDOW, to the selected window.")
   buf = XBUFFER (w->buffer);
   if (XFASTINT (w->last_modified) >= BUF_MODIFF (buf))
     {
-      /* If screen is up to date,
+      /* If frame is up to date,
          use the info recorded about how much text fit on it. */
       if (posint < BUF_Z (buf) - XFASTINT (w->window_end_pos)
           || (XFASTINT (w->window_end_vpos) < height))
@@ -214,7 +214,7 @@ POS defaults to point; WINDOW, to the selected window.")
       posval = *compute_motion (top, 0, 0, posint, height, 0,
                                 XFASTINT (w->width) - 1
                                 - (XFASTINT (w->width) + XFASTINT (w->left)
-                                   != SCREEN_WIDTH (XSCREEN (w->screen))),
+                                   != FRAME_WIDTH (XFRAME (w->frame))),
                                 XINT (w->hscroll), 0);
 
       return posval.vpos < height ? Qt : Qnil;
@@ -258,7 +258,7 @@ DEFUN ("window-width", Fwindow_width, Swindow_width, 0, 1, 0,
 
   /* If this window does not end at the right margin,
      must deduct one column for the border */
-  if ((width + w->left) == SCREEN_WIDTH (XSCREEN (WINDOW_SCREEN (w))))
+  if ((width + w->left) == FRAME_WIDTH (XFRAME (WINDOW_FRAME (w))))
     return width;
   return width - 1;
 }
@@ -292,7 +292,7 @@ NCOL should be zero or positive.")
 
 DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
   "Return a list of the edge coordinates of WINDOW.\n\
-\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of screen.\n\
+\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\
 RIGHT is one more than the rightmost column used by WINDOW,\n\
 and BOTTOM is one more than the bottommost row used by WINDOW\n\
  and its mode-line.")
@@ -338,7 +338,7 @@ coordinates_in_window (w, x, y)
   
   /* Is the character in the right border?  */
   if (*x == left + width - 1
-      && left + width != SCREEN_WIDTH (XSCREEN (w->screen)))
+      && left + width != FRAME_WIDTH (XFRAME (w->frame)))
     return 3;
 
   *x -= left;
@@ -350,9 +350,9 @@ DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
   Scoordinates_in_window_p, 2, 2, 0,
   "Return non-nil if COORDINATES are in WINDOW.\n\
 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\
-measured in characters from the upper-left corner of the screen.\n\
+measured in characters from the upper-left corner of the frame.\n\
 (0 .  0) denotes the character in the upper left corner of the\n\
-screen.\n\
+frame.\n\
 If COORDINATES are in the text portion of WINDOW,\n\
    the coordinates relative to the window are returned.\n\
 If they are in the mode line of WINDOW, `mode-line' is returned.\n\
@@ -393,14 +393,14 @@ If they are on the border between WINDOW and its right sibling,\n\
    right sibling, set it to 2; otherwise set it to 0.  If there is no
    window under x, y return nil and leave *part unmodified.  */
 Lisp_Object
-window_from_coordinates (screen, x, y, part)
-     SCREEN_PTR screen;
+window_from_coordinates (frame, x, y, part)
+     FRAME_PTR frame;
      int x, y;
      int *part;
 {
   register Lisp_Object tem, first;
 
-  tem = first = SCREEN_SELECTED_WINDOW (screen);
+  tem = first = FRAME_SELECTED_WINDOW (frame);
 
   do
     {
@@ -420,23 +420,23 @@ window_from_coordinates (screen, x, y, part)
 }
 
 DEFUN ("window-at", Fwindow_at, Swindow_at, 2, 3, 0,
-  "Return window containing row ROW, column COLUMN on SCREEN.\n\
-If omitted, SCREEN defaults to the currently selected screen.\n\
-The top left corner of the screen is considered to be row 0,\n\
+  "Return window containing row ROW, column COLUMN on FRAME.\n\
+If omitted, FRAME defaults to the currently selected frame.\n\
+The top left corner of the frame is considered to be row 0,\n\
 column 0.")
-  (row, column, screen)
-      Lisp_Object row, column, screen;
+  (row, column, frame)
+      Lisp_Object row, column, frame;
 {
   int part;
 
-  if (NILP (screen))
-    XSET (screen, Lisp_Screen, selected_screen);
+  if (NILP (frame))
+    XSET (frame, Lisp_Frame, selected_frame);
   else
-    CHECK_LIVE_SCREEN (screen, 2);
+    CHECK_LIVE_FRAME (frame, 2);
   CHECK_NUMBER (row, 0);
   CHECK_NUMBER (column, 1);
 
-  return window_from_coordinates (XSCREEN (screen),
+  return window_from_coordinates (XFRAME (frame),
                                   XINT (row), XINT (column),
                                   &part);
 }
@@ -631,11 +631,11 @@ replace_window (old, replacement)
   register Lisp_Object tem;
   register struct window *o = XWINDOW (old), *p = XWINDOW (replacement);
 
-  /* If OLD is its screen's root_window, then replacement is the new
-     root_window for that screen.  */
+  /* If OLD is its frame's root_window, then replacement is the new
+     root_window for that frame.  */
 
-  if (old == SCREEN_ROOT_WINDOW (XSCREEN (o->screen)))
-    SCREEN_ROOT_WINDOW (XSCREEN (o->screen)) = replacement;
+  if (old == FRAME_ROOT_WINDOW (XFRAME (o->frame)))
+    FRAME_ROOT_WINDOW (XFRAME (o->frame)) = replacement;
 
   p->left = o->left;
   p->top = o->top;
@@ -748,7 +748,7 @@ DEFUN ("delete-window", Fdelete_window, Sdelete_window, 0, 1, "",
 }
 
 
-extern Lisp_Object next_screen (), prev_screen ();
+extern Lisp_Object next_frame (), prev_frame ();
 
 DEFUN ("next-window", Fnext_window, Snext_window, 0, 3, 0,
   "Return next window after WINDOW in canonical ordering of windows.\n\
@@ -759,17 +759,17 @@ if not active.  MINIBUF nil or omitted means count the minibuffer iff\n\
 it is active.  MINIBUF neither t nor nil means not to count the\n\
 minibuffer even if it is active.\n\
 \n\
-Several screens may share a single minibuffer; if the minibuffer\n\
-counts, all windows on all screens that share that minibuffer count\n\
+Several frames may share a single minibuffer; if the minibuffer\n\
+counts, all windows on all frames that share that minibuffer count\n\
 too.  This means that next-window may be used to iterate through the\n\
-set of windows even when the minibuffer is on another screen.  If the\n\
-minibuffer does not count, only windows from WINDOW's screen count.\n\
+set of windows even when the minibuffer is on another frame.  If the\n\
+minibuffer does not count, only windows from WINDOW's frame count.\n\
 \n\
-Optional third arg ALL-SCREENS t means include windows on all screens.\n\
-ALL-SCREENS nil or omitted means cycle within the screens as specified\n\
-above.  If neither nil nor t, restrict to WINDOW's screen.")
-  (window, minibuf, all_screens)
-     register Lisp_Object window, minibuf, all_screens;
+Optional third arg ALL-FRAMES t means include windows on all frames.\n\
+ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
+above.  If neither nil nor t, restrict to WINDOW's frame.")
+  (window, minibuf, all_frames)
+     register Lisp_Object window, minibuf, all_frames;
 {
   register Lisp_Object tem;
   Lisp_Object start_window;
@@ -786,17 +786,17 @@ above.  If neither nil nor t, restrict to WINDOW's screen.")
   if (NILP (minibuf))
     minibuf = (minibuf_level ? Qt : Qlambda);
 
-  /* all_screens == nil doesn't specify which screens to include.
-     Decide which screens it includes.  */
-  if (NILP (all_screens))
-    all_screens = (EQ (minibuf, Qt)
-                   ? (SCREEN_MINIBUF_WINDOW
-                      (XSCREEN
-                       (WINDOW_SCREEN
+  /* all_frames == nil doesn't specify which frames to include.
+     Decide which frames it includes.  */
+  if (NILP (all_frames))
+    all_frames = (EQ (minibuf, Qt)
+                   ? (FRAME_MINIBUF_WINDOW
+                      (XFRAME
+                       (WINDOW_FRAME
                         (XWINDOW (window)))))
                    : Qnil);
-  else if (! EQ (all_screens, Qt))
-    all_screens = Qnil;
+  else if (! EQ (all_frames, Qt))
+    all_frames = Qnil;
 
   /* Do this loop at least once, to get the next window, and perhaps
      again, if we hit the minibuffer and that is not acceptable.  */
@@ -809,14 +809,14 @@ above.  If neither nil nor t, restrict to WINDOW's screen.")
           window = tem;
         else
           {
-            /* We've reached the end of this screen.
-               Which other screens are acceptable?  */
-            tem = WINDOW_SCREEN (XWINDOW (window));
-#ifdef MULTI_SCREEN
-            if (! NILP (all_screens))
-              tem = next_screen (tem, all_screens);
+            /* We've reached the end of this frame.
+               Which other frames are acceptable?  */
+            tem = WINDOW_FRAME (XWINDOW (window));
+#ifdef MULTI_FRAME
+            if (! NILP (all_frames))
+              tem = next_frame (tem, all_frames);
 #endif
-            tem = SCREEN_ROOT_WINDOW (XSCREEN (tem));
+            tem = FRAME_ROOT_WINDOW (XFRAME (tem));
 
             break;
           }
@@ -855,18 +855,18 @@ if not active.  MINIBUF nil or omitted means count the minibuffer iff\n\
 it is active.  MINIBUF neither t nor nil means not to count the\n\
 minibuffer even if it is active.\n\
 \n\
-Several screens may share a single minibuffer; if the minibuffer\n\
-counts, all windows on all screens that share that minibuffer count\n\
+Several frames may share a single minibuffer; if the minibuffer\n\
+counts, all windows on all frames that share that minibuffer count\n\
 too.  This means that previous-window may be used to iterate through\n\
-the set of windows even when the minibuffer is on another screen.  If\n\
-the minibuffer does not count, only windows from WINDOW's screen\n\
+the set of windows even when the minibuffer is on another frame.  If\n\
+the minibuffer does not count, only windows from WINDOW's frame\n\
 count.\n\
 \n\
-Optional third arg ALL-SCREENS t means include windows on all screens.\n\
-ALL-SCREENS nil or omitted means cycle within the screens as specified\n\
-above.  If neither nil nor t, restrict to WINDOW's screen.")
-  (window, minibuf, all_screens)
-     register Lisp_Object window, minibuf, all_screens;
+Optional third arg ALL-FRAMES t means include windows on all frames.\n\
+ALL-FRAMES nil or omitted means cycle within the frames as specified\n\
+above.  If neither nil nor t, restrict to WINDOW's frame.")
+  (window, minibuf, all_frames)
+     register Lisp_Object window, minibuf, all_frames;
 {
   register Lisp_Object tem;
   Lisp_Object start_window;
@@ -883,17 +883,17 @@ above.  If neither nil nor t, restrict to WINDOW's screen.")
   if (NILP (minibuf))
     minibuf = (minibuf_level ? Qt : Qlambda);
 
-  /* all_screens == nil doesn't specify which screens to include.
-     Decide which screens it includes.  */
-  if (NILP (all_screens))
-    all_screens = (EQ (minibuf, Qt)
-                   ? (SCREEN_MINIBUF_WINDOW
-                      (XSCREEN
-                       (WINDOW_SCREEN
+  /* all_frames == nil doesn't specify which frames to include.
+     Decide which frames it includes.  */
+  if (NILP (all_frames))
+    all_frames = (EQ (minibuf, Qt)
+                   ? (FRAME_MINIBUF_WINDOW
+                      (XFRAME
+                       (WINDOW_FRAME
                         (XWINDOW (window)))))
                    : Qnil);
-  else if (! EQ (all_screens, Qt))
-    all_screens = Qnil;
+  else if (! EQ (all_frames, Qt))
+    all_frames = Qnil;
 
   /* Do this loop at least once, to get the previous window, and perhaps
      again, if we hit the minibuffer and that is not acceptable.  */
@@ -906,14 +906,14 @@ above.  If neither nil nor t, restrict to WINDOW's screen.")
           window = tem;
         else
           {
-            /* We have found the top window on the screen.
-               Which screens are acceptable?  */
-            tem = WINDOW_SCREEN (XWINDOW (window));
-#ifdef MULTI_SCREEN
-            if (! NILP (all_screens))
-              tem = next_screen (tem, all_screens);
+            /* We have found the top window on the frame.
+               Which frames are acceptable?  */
+            tem = WINDOW_FRAME (XWINDOW (window));
+#ifdef MULTI_FRAME
+            if (! NILP (all_frames))
+              tem = next_frame (tem, all_frames);
 #endif
-            tem = SCREEN_ROOT_WINDOW (XSCREEN (tem));
+            tem = FRAME_ROOT_WINDOW (XFRAME (tem));
 
             break;
           }
@@ -945,13 +945,13 @@ above.  If neither nil nor t, restrict to WINDOW's screen.")
 }
 
 DEFUN ("other-window", Fother_window, Sother_window, 1, 2, "p",
-  "Select the ARG'th different window on this screen.\n\
-All windows on current screen are arranged in a cyclic order.\n\
+  "Select the ARG'th different window on this frame.\n\
+All windows on current frame are arranged in a cyclic order.\n\
 This command selects the window ARG steps away in that order.\n\
 A negative ARG moves in the opposite order.  If the optional second\n\
-argument ALL_SCREENS is non-nil, cycle through all screens.")
-  (n, all_screens)
-     register Lisp_Object n, all_screens;
+argument ALL_FRAMES is non-nil, cycle through all frames.")
+  (n, all_frames)
+     register Lisp_Object n, all_frames;
 {
   register int i;
   register Lisp_Object w;
@@ -962,12 +962,12 @@ argument ALL_SCREENS is non-nil, cycle through all screens.")
 
   while (i > 0)
     {
-      w = Fnext_window (w, Qnil, all_screens);
+      w = Fnext_window (w, Qnil, all_frames);
       i--;
     }
   while (i < 0)
     {
-      w = Fprevious_window (w, Qnil, all_screens);
+      w = Fprevious_window (w, Qnil, all_frames);
       i++;
     }
   Fselect_window (w);
@@ -976,8 +976,8 @@ argument ALL_SCREENS is non-nil, cycle through all screens.")
 
 /* Look at all windows, performing an operation specified by TYPE
    with argument OBJ.
-   If SCREENS is Qt, look at all screens, if Qnil, look at just the selected
-   screen.  If SCREENS is a screen, just look at windows on that screen.
+   If FRAMES is Qt, look at all frames, if Qnil, look at just the selected
+   frame.  If FRAMES is a frame, just look at windows on that frame.
    If MINI is non-zero, perform the operation on minibuffer windows too.
 */
 
@@ -993,34 +993,34 @@ enum window_loop
 };
 
 static Lisp_Object
-window_loop (type, obj, mini, screens)
+window_loop (type, obj, mini, frames)
      enum window_loop type;
-     register Lisp_Object obj, screens;
+     register Lisp_Object obj, frames;
      int mini;
 {
   register Lisp_Object w;
   register Lisp_Object best_window;
   register Lisp_Object next_window;
   register Lisp_Object first_window;
-  SCREEN_PTR screen;
-
-  /* If we're only looping through windows on a particular screen,
-     screen points to that screen.  If we're looping through windows
-     on all screens, screen is 0.  */
-  if (SCREENP (screens))
-    screen = XSCREEN (screens);
-  else if (NILP (screens))
-    screen = selected_screen;
+  FRAME_PTR frame;
+
+  /* If we're only looping through windows on a particular frame,
+     frame points to that frame.  If we're looping through windows
+     on all frames, frame is 0.  */
+  if (FRAMEP (frames))
+    frame = XFRAME (frames);
+  else if (NILP (frames))
+    frame = selected_frame;
   else
-    screen = 0;
+    frame = 0;
 
   /* Pick a window to start with.  */
   if (XTYPE (obj) == Lisp_Window)
     first_window = obj;
-  else if (screen)
-    first_window = SCREEN_SELECTED_WINDOW (screen);
+  else if (frame)
+    first_window = FRAME_SELECTED_WINDOW (frame);
   else
-    first_window = SCREEN_SELECTED_WINDOW (selected_screen);
+    first_window = FRAME_SELECTED_WINDOW (selected_frame);
 
   w = first_window;
   best_window = Qnil;
@@ -1028,13 +1028,13 @@ window_loop (type, obj, mini, screens)
     {
       /* Pick the next window now, since some operations will delete
          the current window.  */
-#ifdef MULTI_SCREEN
-      if (screen)
+#ifdef MULTI_FRAME
+      if (frame)
         next_window = Fnext_window (w, (mini ? Qt : Qnil), Qlambda);
       else
-#endif  /* MULTI_SCREEN */
-        /* We know screen is 0, so we're looping through all screens.
-           Or we know this isn't a MULTI_SCREEN Emacs, so who cares?  */
+#endif  /* MULTI_FRAME */
+        /* We know frame is 0, so we're looping through all frames.
+           Or we know this isn't a MULTI_FRAME Emacs, so who cares?  */
         next_window = Fnext_window (w, mini ? Qt : Qnil, Qt);
 
       if (!MINI_WINDOW_P (XWINDOW (w))
@@ -1043,9 +1043,9 @@ window_loop (type, obj, mini, screens)
           {
           case GET_BUFFER_WINDOW:
 #if 0
-            /* Ignore invisible and iconified screens.  */
-            if (! SCREEN_VISIBLE_P (XSCREEN (WINDOW_SCREEN (XWINDOW (w))))
-                || SCREEN_ICONIFIED_P (XSCREEN (WINDOW_SCREEN (XWINDOW (w)))))
+            /* Ignore invisible and iconified frames.  */
+            if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w))))
+                || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w)))))
               break;
 #endif
             if (XBUFFER (XWINDOW (w)->buffer) == XBUFFER (obj))
@@ -1055,12 +1055,12 @@ window_loop (type, obj, mini, screens)
           case GET_LRU_WINDOW:
             /* t as arg means consider only full-width windows */
             if (!NILP (obj) && XFASTINT (XWINDOW (w)->width)
-                != SCREEN_WIDTH (screen))
+                != FRAME_WIDTH (frame))
               break;
 #if 0
-            /* Ignore invisible and iconified screens.  */
-            if (! SCREEN_VISIBLE_P (XSCREEN (WINDOW_SCREEN (XWINDOW (w))))
-                || SCREEN_ICONIFIED_P (XSCREEN (WINDOW_SCREEN (XWINDOW (w)))))
+            /* Ignore invisible and iconified frames.  */
+            if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w))))
+                || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w)))))
               break;
 #endif
             /* Ignore dedicated windows and minibuffers.  */
@@ -1082,7 +1082,7 @@ window_loop (type, obj, mini, screens)
             if (EQ (XWINDOW (w)->buffer, obj))
               {
                 /* If we're deleting the buffer displayed in the only window
-                   on the screen, find a new buffer to display there.  */
+                   on the frame, find a new buffer to display there.  */
                 if (NILP (XWINDOW (w)->parent))
                   {
                     Lisp_Object new_buffer = Fother_buffer (obj);
@@ -1099,9 +1099,9 @@ window_loop (type, obj, mini, screens)
 
           case GET_LARGEST_WINDOW:
 #if 0
-            /* Ignore invisible and iconified screens.  */
-            if (! SCREEN_VISIBLE_P (XSCREEN (WINDOW_SCREEN (XWINDOW (w))))
-                || SCREEN_ICONIFIED_P (XSCREEN (WINDOW_SCREEN (XWINDOW (w)))))
+            /* Ignore invisible and iconified frames.  */
+            if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w))))
+                || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w)))))
               break;
 #endif
             /* Ignore dedicated windows and minibuffers.  */
@@ -1142,49 +1142,49 @@ window_loop (type, obj, mini, screens)
 
 DEFUN ("get-lru-window", Fget_lru_window, Sget_lru_window, 0, 1, 0,
   "Return the window least recently selected or used for display.\n\
-If optional argument SCREENS is t, search all screens.  If SCREEN is a\n\
-screen, search only that screen.\n")
-  (screens)
-    Lisp_Object screens;
+If optional argument FRAMES is t, search all frames.  If FRAME is a\n\
+frame, search only that frame.\n")
+  (frames)
+    Lisp_Object frames;
 {
   register Lisp_Object w;
   /* First try for a window that is full-width */
-  w = window_loop (GET_LRU_WINDOW, Qt, 0, screens);
+  w = window_loop (GET_LRU_WINDOW, Qt, 0, frames);
   if (!NILP (w) && !EQ (w, selected_window))
     return w;
   /* If none of them, try the rest */
-  return window_loop (GET_LRU_WINDOW, Qnil, 0, screens);
+  return window_loop (GET_LRU_WINDOW, Qnil, 0, frames);
 }
 
 DEFUN ("get-largest-window", Fget_largest_window, Sget_largest_window, 0, 1, 0,
   "Return the largest window in area.\n\
-If optional argument SCREENS is t, search all screens.  If SCREEN is a\n\
-screen, search only that screen.\n")
-  (screen)
-    Lisp_Object screen;
+If optional argument FRAMES is t, search all frames.  If FRAME is a\n\
+frame, search only that frame.\n")
+  (frame)
+    Lisp_Object frame;
 {
   return window_loop (GET_LARGEST_WINDOW, Qnil, 0,
-                      screen);
+                      frame);
 }
 
 DEFUN ("get-buffer-window", Fget_buffer_window, Sget_buffer_window, 1, 2, 0,
   "Return a window currently displaying BUFFER, or nil if none.\n\
-If optional argument SCREENS is t, search all screens.  If SCREEN is a\n\
-screen, search only that screen.\n")
-  (buffer, screen)
-    Lisp_Object buffer, screen;
+If optional argument FRAMES is t, search all frames.  If FRAME is a\n\
+frame, search only that frame.\n")
+  (buffer, frame)
+    Lisp_Object buffer, frame;
 {
   buffer = Fget_buffer (buffer);
   if (XTYPE (buffer) == Lisp_Buffer)
-    return window_loop (GET_BUFFER_WINDOW, buffer, 1, screen);
+    return window_loop (GET_BUFFER_WINDOW, buffer, 1, frame);
   else
     return Qnil;
 }
 
 DEFUN ("delete-other-windows", Fdelete_other_windows, Sdelete_other_windows,
   0, 1, "",
-  "Make WINDOW (or the selected window) fill its screen.\n\
-Only the screen WINDOW is on is affected.")
+  "Make WINDOW (or the selected window) fill its frame.\n\
+Only the frame WINDOW is on is affected.")
   (window)
      Lisp_Object window;
 {
@@ -1201,7 +1201,7 @@ Only the screen WINDOW is on is affected.")
   w = XWINDOW (window);
   top = XFASTINT (w->top);
 
-  window_loop (DELETE_OTHER_WINDOWS, window, 0, WINDOW_SCREEN(w));
+  window_loop (DELETE_OTHER_WINDOWS, window, 0, WINDOW_FRAME(w));
 
   Fset_buffer (w->buffer);
   SET_PT (marker_position (w->start));
@@ -1439,14 +1439,14 @@ before each command.")
                ow->buffer);
 
   selected_window = window;
-#ifdef MULTI_SCREEN
-  if (XSCREEN (WINDOW_SCREEN (w)) != selected_screen)
+#ifdef MULTI_FRAME
+  if (XFRAME (WINDOW_FRAME (w)) != selected_frame)
     {
-      XSCREEN (WINDOW_SCREEN (w))->selected_window = window;
-      Fselect_screen (WINDOW_SCREEN (w), Qnil);
+      XFRAME (WINDOW_FRAME (w))->selected_window = window;
+      Fselect_frame (WINDOW_FRAME (w), Qnil);
     }
   else
-    selected_screen->selected_window = window;
+    selected_frame->selected_window = window;
 #endif
 
   record_buffer (w->buffer);
@@ -1499,48 +1499,48 @@ Returns the window displaying BUFFER.")
       && (NILP (not_this_window) || !EQ (window, selected_window)))
     return window;
 
-#ifdef MULTI_SCREEN
-  /* If there are no screens open that have more than a minibuffer,
-     we need to create a new screen.  */
-  if (pop_up_screens || last_nonminibuf_screen == 0)
+#ifdef MULTI_FRAME
+  /* If there are no frames open that have more than a minibuffer,
+     we need to create a new frame.  */
+  if (pop_up_frames || last_nonminibuf_frame == 0)
     {
       window
-        = Fscreen_selected_window (call0 (Vpop_up_screen_function));
+        = Fframe_selected_window (call0 (Vpop_up_frame_function));
       Fset_window_buffer (window, buffer);
 #if 0
-      Fselect_screen (XWINDOW (window)->screen, Qnil);
+      Fselect_frame (XWINDOW (window)->frame, Qnil);
 #endif
       return window;
     }
-#endif /* MULTI_SCREEN */
+#endif /* MULTI_FRAME */
 
   if (pop_up_windows
-#ifdef MULTI_SCREEN
-      || SCREEN_MINIBUF_ONLY_P (selected_screen)
+#ifdef MULTI_FRAME
+      || FRAME_MINIBUF_ONLY_P (selected_frame)
 #endif
       )
     {
-      Lisp_Object screens = Qnil;
+      Lisp_Object frames = Qnil;
       
-#ifdef MULTI_SCREEN
-      if (SCREEN_MINIBUF_ONLY_P (selected_screen))
-        XSET (screens, Lisp_Screen, last_nonminibuf_screen);
+#ifdef MULTI_FRAME
+      if (FRAME_MINIBUF_ONLY_P (selected_frame))
+        XSET (frames, Lisp_Frame, last_nonminibuf_frame);
 #endif
       /* Don't try to create a window if would get an error */
       if (split_height_threshold < window_min_height << 1)
         split_height_threshold = window_min_height << 1;
 
-      window = Fget_largest_window (screens);
+      window = Fget_largest_window (frames);
 
       if (!NILP (window)
           && window_height (window) >= split_height_threshold
           &&
           (XFASTINT (XWINDOW (window)->width)
-           == SCREEN_WIDTH (XSCREEN (WINDOW_SCREEN (XWINDOW (window))))))
+           == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window))))))
         window = Fsplit_window (window, Qnil, Qnil);
       else
         {
-          window = Fget_lru_window (screens);
+          window = Fget_lru_window (frames);
           if ((EQ (window, selected_window)
                || EQ (XWINDOW (window)->parent, Qnil))
               && window_height (window) >= window_min_height << 1)
@@ -1576,10 +1576,10 @@ temp_output_buffer_show (buf)
     {
       window = Fdisplay_buffer (buf, Qnil);
 
-#ifdef MULTI_SCREEN
-      if (XSCREEN (XWINDOW (window)->screen) != selected_screen)
-        Fmake_screen_visible (XWINDOW (window)->screen);
-#endif /* MULTI_SCREEN */
+#ifdef MULTI_FRAME
+      if (XFRAME (XWINDOW (window)->frame) != selected_frame)
+        Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window)));
+#endif /* MULTI_FRAME */
       Vminibuf_scroll_window = window;
       w = XWINDOW (window);
       XFASTINT (w->hscroll) = 0;
@@ -1654,8 +1654,8 @@ and put SIZE columns in the first of the pair.")
 
   if (MINI_WINDOW_P (o))
     error ("Attempt to split minibuffer window");
-  else if (SCREEN_NO_SPLIT_P (XSCREEN (WINDOW_SCREEN (o))))
-    error ("Attempt to split unsplittable screen");
+  else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o))))
+    error ("Attempt to split unsplittable frame");
 
   /* Smaller values might permit a crash.  */
   if (window_min_width < 2)
@@ -1698,7 +1698,7 @@ and put SIZE columns in the first of the pair.")
   new = make_window ();
   p = XWINDOW (new);
 
-  p->screen = o->screen;
+  p->frame = o->frame;
   p->next = o->next;
   if (!NILP (p->next))
     XWINDOW (p->next)->prev = new;
@@ -1709,7 +1709,7 @@ and put SIZE columns in the first of the pair.")
 
   Fset_window_buffer (new, o->buffer);
 
-  /* Apportion the available screen space among the two new windows */
+  /* Apportion the available frame space among the two new windows */
 
   if (!NILP (horflag))
     {
@@ -1833,14 +1833,14 @@ change_window_height (delta, widthflag)
     maxdelta = (!NILP (parent) ? (*sizefun) (parent) - *sizep
                 : !NILP (p->next) ? (*sizefun) (p->next) - MINSIZE (p->next)
                 : !NILP (p->prev) ? (*sizefun) (p->prev) - MINSIZE (p->prev)
-                /* This is a screen with only one window, a minibuffer-only
-                   or a minibufferless screen.  */
+                /* This is a frame with only one window, a minibuffer-only
+                   or a minibufferless frame.  */
                 : (delta = 0));
 
     if (delta > maxdelta)
       /* This case traps trying to make the minibuffer
-         the full screen, or make the only window aside from the
-         minibuffer the full screen.  */
+         the full frame, or make the only window aside from the
+         minibuffer the full frame.  */
       delta = maxdelta;
 
     if (delta == 0)
@@ -1914,7 +1914,7 @@ window_internal_height (w)
 
   if (!NILP (w->parent) || !NILP (w->vchild) || !NILP (w->hchild)
       || !NILP (w->next) || !NILP (w->prev)
-      || SCREEN_WANTS_MODELINE_P (XSCREEN (WINDOW_SCREEN (w))))
+      || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w))))
     return ht - 1;
 
   return ht;
@@ -2145,11 +2145,11 @@ Default for ARG is window width minus 2.")
 }
 
 DEFUN ("recenter", Frecenter, Srecenter, 0, 1, "P",
-  "Center point in window and redisplay screen.  With ARG, put point on line ARG.\n\
+  "Center point in window and redisplay frame.  With ARG, put point on line ARG.\n\
 The desired position of point is always relative to the current window.\n\
-Just C-u as prefix means put point in the center of the screen.\n\
-No arg (i.e., it is nil) erases the entire screen and then\n\
-redraws with point in the center.")
+Just C-u as prefix means put point in the center of the window.\n\
+No arg (i.e., it is nil) erases the entire frame and then\n\
+redraws with point in the center of the current window.")
   (n)
      register Lisp_Object n;
 {
@@ -2159,9 +2159,9 @@ redraws with point in the center.")
 
   if (NILP (n))
     {
-      extern int screen_garbaged;
+      extern int frame_garbaged;
 
-      SET_SCREEN_GARBAGED (XSCREEN (WINDOW_SCREEN (w)));
+      SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w)));
       XFASTINT (n) = ht / 2;
     }
   else if (XTYPE (n) == Lisp_Cons) /* Just C-u. */
@@ -2193,7 +2193,7 @@ DEFUN ("move-to-window-line", Fmove_to_window_line, Smove_to_window_line,
   1, 1, "P",
   "Position point relative to window.\n\
 With no argument, position text at center of window.\n\
-An argument specifies screen line; zero means top of window,\n\
+An argument specifies frame line; zero means top of window,\n\
 negative means relative to bottom of window.")
   (arg)
      register Lisp_Object arg;
@@ -2229,7 +2229,7 @@ struct save_window_data
   {
     int size_from_Lisp_Vector_struct;
     struct Lisp_Vector *next_from_Lisp_Vector_struct;
-    Lisp_Object screen_width, screen_height;
+    Lisp_Object frame_width, frame_height;
     Lisp_Object current_window;
     Lisp_Object current_buffer;
     Lisp_Object minibuf_scroll_window;
@@ -2285,7 +2285,7 @@ by `current-window-configuration' (which see).")
   register Lisp_Object tem;
   Lisp_Object new_current_buffer;
   int k;
-  SCREEN_PTR s;
+  FRAME_PTR f;
 
   while (XTYPE (arg) != Lisp_Window_Configuration)
     {
@@ -2295,16 +2295,16 @@ by `current-window-configuration' (which see).")
   data = (struct save_window_data *) XVECTOR (arg);
   saved_windows = XVECTOR (data->saved_windows);
 
-  s = XSCREEN (XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->screen);
+  f = XFRAME (XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame);
 
-  if (XFASTINT (data->screen_height) != SCREEN_HEIGHT (s)
-      || XFASTINT (data->screen_width) != SCREEN_WIDTH (s))
+  if (XFASTINT (data->frame_height) != FRAME_HEIGHT (f)
+      || XFASTINT (data->frame_width) != FRAME_WIDTH (f))
     {
       /* Presumably something clever could be done.
          However, it doesn't seem worth the effort */
-      error ("Screen size %dx%d in saved window configuration mismatches screen.",
-             XFASTINT (data->screen_height),
-             XFASTINT (data->screen_width));
+      error ("Frame size %dx%d in saved window configuration mismatches frame.",
+             XFASTINT (data->frame_height),
+             XFASTINT (data->frame_width));
     }
 
   windows_or_buffers_changed++;
@@ -2312,12 +2312,12 @@ by `current-window-configuration' (which see).")
   if (NILP (XBUFFER (new_current_buffer)->name))
     new_current_buffer = Qnil;
 
-  /* Mark all windows now on screen as "deleted".
+  /* Mark all windows now on frame as "deleted".
      Restoring the new configuration "undeletes" any that are in it.  */
 
-  delete_all_subwindows (XWINDOW (SCREEN_ROOT_WINDOW (s)));
+  delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f)));
 #if 0
-  /* This loses when the minibuf screen is not s. */
+  /* This loses when the minibuf frame is not f. */
   delete_all_subwindows (XWINDOW (XWINDOW (minibuf_window)->prev));
 #endif
 
@@ -2335,12 +2335,12 @@ by `current-window-configuration' (which see).")
       if (!NILP (p->prev))
         {
           w->prev = SAVED_WINDOW_N (saved_windows, XFASTINT (p->prev))->window;
-#ifdef MULTI_SCREEN
-          /* This is true for a minibuffer-only screen. */
+#ifdef MULTI_FRAME
+          /* This is true for a minibuffer-only frame. */
           if (w->mini_p && EQ (w->prev, p->window))
             w->next = Qnil;
           else
-#endif  /* MULTI_SCREEN */
+#endif  /* MULTI_FRAME */
             XWINDOW (w->prev)->next = p->window;
         }
       else
@@ -2412,14 +2412,14 @@ by `current-window-configuration' (which see).")
         }
     }
 
-  SCREEN_ROOT_WINDOW (s) = data->root_window;
+  FRAME_ROOT_WINDOW (f) = data->root_window;
 
-#ifdef MULTI_SCREEN
-  if (s != selected_screen && ! SCREEN_IS_TERMCAP (s))
-    Fselect_screen (WINDOW_SCREEN (XWINDOW (data->root_window)), Qnil);
+#ifdef MULTI_FRAME
+  if (f != selected_frame && ! FRAME_IS_TERMCAP (f))
+    Fselect_frame (WINDOW_FRAME (XWINDOW (data->root_window)), Qnil);
 #endif
 
-  if (s == selected_screen)
+  if (f == selected_frame)
     {
       Fselect_window (data->current_window);
       if (!NILP (new_current_buffer))
@@ -2432,7 +2432,7 @@ by `current-window-configuration' (which see).")
   return (Qnil);
 }
 
-/* Mark all windows now on screen as deleted
+/* Mark all windows now on frame as deleted
    by setting their buffers to nil.  */
 
 static void
@@ -2536,45 +2536,45 @@ save_window_save (window, vector, i)
 
 DEFUN ("current-window-configuration",
         Fcurrent_window_configuration, Scurrent_window_configuration, 0, 1, 0,
-  "Return an object representing the current window configuration of SCREEN.\n\
-If SCREEN is nil or omitted, use the selected screen.\n\
+  "Return an object representing the current window configuration of FRAME.\n\
+If FRAME is nil or omitted, use the selected frame.\n\
 This describes the number of windows, their sizes and current buffers,\n\
 and for each displayed buffer, where display starts, and the positions of\n\
 point and mark.  An exception is made for point in the current buffer:\n\
 its value is -not- saved.")
-  (screen)
-     Lisp_Object screen;
+  (frame)
+     Lisp_Object frame;
 {
   register Lisp_Object tem;
   register int n_windows;
   register struct save_window_data *data;
   register int i;
-  SCREEN_PTR s;
+  FRAME_PTR f;
 
-  if (NILP (screen))
-    s = selected_screen;
+  if (NILP (frame))
+    f = selected_frame;
   else
     {
-      CHECK_LIVE_SCREEN (screen, 0);
-      s = XSCREEN (screen);
+      CHECK_LIVE_FRAME (frame, 0);
+      f = XFRAME (frame);
     }
 
-  n_windows = count_windows (XWINDOW (SCREEN_ROOT_WINDOW (s)));
+  n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
   data = (struct save_window_data *)
            XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE),
                                   Qnil));
-  XFASTINT (data->screen_width) = SCREEN_WIDTH (s);
-  XFASTINT (data->screen_height) = SCREEN_HEIGHT (s);
-  data->current_window = SCREEN_SELECTED_WINDOW (s);
+  XFASTINT (data->frame_width) = FRAME_WIDTH (f);
+  XFASTINT (data->frame_height) = FRAME_HEIGHT (f);
+  data->current_window = FRAME_SELECTED_WINDOW (f);
   XSET (data->current_buffer, Lisp_Buffer, current_buffer);
   data->minibuf_scroll_window = Vminibuf_scroll_window;
-  data->root_window = SCREEN_ROOT_WINDOW (s);
+  data->root_window = FRAME_ROOT_WINDOW (f);
   tem = Fmake_vector (make_number (n_windows), Qnil);
   data->saved_windows = tem;
   for (i = 0; i < n_windows; i++)
     XVECTOR (tem)->contents[i]
       = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE), Qnil);
-  save_window_save (SCREEN_ROOT_WINDOW (s),
+  save_window_save (FRAME_ROOT_WINDOW (f),
                     XVECTOR (tem), 0);
   XSET (tem, Lisp_Window_Configuration, data);
   return (tem);
@@ -2600,47 +2600,47 @@ Does not restore the value of point in current buffer.")
 
 init_window_once ()
 {
-#ifdef MULTI_SCREEN
-  selected_screen = make_terminal_screen ();
-  minibuf_window = selected_screen->minibuffer_window;
-  selected_window = selected_screen->selected_window;
-  last_nonminibuf_screen = selected_screen;
-#else /* not MULTI_SCREEN */
+#ifdef MULTI_FRAME
+  selected_frame = make_terminal_frame ();
+  minibuf_window = selected_frame->minibuffer_window;
+  selected_window = selected_frame->selected_window;
+  last_nonminibuf_frame = selected_frame;
+#else /* not MULTI_FRAME */
   extern Lisp_Object get_minibuffer ();
 
-  SCREEN_ROOT_WINDOW (selected_screen) = make_window ();
+  FRAME_ROOT_WINDOW (selected_frame) = make_window ();
   minibuf_window = make_window ();
 
-  XWINDOW (SCREEN_ROOT_WINDOW (selected_screen))->next = minibuf_window;
-  XWINDOW (minibuf_window)->prev = SCREEN_ROOT_WINDOW (selected_screen);
+  XWINDOW (FRAME_ROOT_WINDOW (selected_frame))->next = minibuf_window;
+  XWINDOW (minibuf_window)->prev = FRAME_ROOT_WINDOW (selected_frame);
 
   /* These values 9 and 10 are arbitrary,
      just so that there is "something there."
      Correct values are put in in init_xdisp */
 
-  XFASTINT (XWINDOW (SCREEN_ROOT_WINDOW (selected_screen))->width) = 10;
+  XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame))->width) = 10;
   XFASTINT (XWINDOW (minibuf_window)->width) = 10;
 
-  XFASTINT (XWINDOW (SCREEN_ROOT_WINDOW (selected_screen))->height) = 9;
+  XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame))->height) = 9;
   XFASTINT (XWINDOW (minibuf_window)->top) = 9;
   XFASTINT (XWINDOW (minibuf_window)->height) = 1;
 
   /* Prevent error in Fset_window_buffer.  */
-  XWINDOW (SCREEN_ROOT_WINDOW (selected_screen))->buffer = Qt;
+  XWINDOW (FRAME_ROOT_WINDOW (selected_frame))->buffer = Qt;
   XWINDOW (minibuf_window)->buffer = Qt;
 
   /* Now set them up for real.  */
-  Fset_window_buffer (SCREEN_ROOT_WINDOW (selected_screen),
+  Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame),
                       Fcurrent_buffer ());
   Fset_window_buffer (minibuf_window, get_minibuffer (0));
 
-  selected_window = SCREEN_ROOT_WINDOW (selected_screen);
+  selected_window = FRAME_ROOT_WINDOW (selected_frame);
   /* Make sure this window seems more recently used than
      a newly-created, never-selected window.  Increment
      window_select_count so the first selection ever will get
      something newer than this.  */
   XFASTINT (XWINDOW (selected_window)->use_time) = ++window_select_count;
-#endif /* not MULTI_SCREEN */
+#endif /* not MULTI_FRAME */
 }
 
 syms_of_window ()
@@ -2670,13 +2670,13 @@ work using this function.");
 
   DEFVAR_LISP ("mouse-event", &Vmouse_event,
      "The last mouse-event object.  A list of four elements:\n\
-  ((X-POS Y-POS) WINDOW SCREEN-PART KEYSEQ).\n\
+  ((X-POS Y-POS) WINDOW FRAME-PART KEYSEQ).\n\
 KEYSEQ is a string, the key sequence to be looked up in the mouse maps.\n\
 WINDOW is the window that the click applies do.\n\
-If SCREEN-PART is non-nil, the event was on a scrollbar;\n\
+If FRAME-PART is non-nil, the event was on a scrollbar;\n\
 then Y-POS is really the total length of the scrollbar, while X-POS is\n\
 the relative position of the scrollbar's value within that total length.\n\
-SCREEN-PART is one of the following symbols:\n\
+FRAME-PART is one of the following symbols:\n\
  `vertical-scrollbar', `vertical-slider',\n\
  `vertical-thumbup', `vertical-thumbdown',\n\
  `horizontal-scrollbar', `horizontal-slider',\n\
@@ -2691,18 +2691,18 @@ SCREEN-PART is one of the following symbols:\n\
     "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window.");
   Vother_window_scroll_buffer = Qnil;
 
-#ifdef MULTI_SCREEN
-  DEFVAR_BOOL ("pop-up-screens", &pop_up_screens,
+#ifdef MULTI_FRAME
+  DEFVAR_BOOL ("pop-up-frames", &pop_up_frames,
     "*Non-nil means `display-buffer' should make a separate X-window.");
-  pop_up_screens = 0;
+  pop_up_frames = 0;
 
-  DEFVAR_LISP ("pop-up-screen-function", &Vpop_up_screen_function,
-    "*If non-nil, function to call to handle automatic new screen creation.\n\
-It is called with no arguments and should return a newly created screen.\n\
+  DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function,
+    "*If non-nil, function to call to handle automatic new frame creation.\n\
+It is called with no arguments and should return a newly created frame.\n\
 \n\
-A typical value might be `(lambda () (x-create-screen auto-screen-parms))'\n\
-where `auto-screen-parms' would hold the default screen parameters.");
-  Vpop_up_screen_function = Qnil;
+A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\
+where `pop-up-frame-alist' would hold the default frame parameters.");
+  Vpop_up_frame_function = Qnil;
 #endif
 
   DEFVAR_BOOL ("pop-up-windows", &pop_up_windows,
diff --git a/src/window.h b/src/window.h
index 62a6c5b0c2e..8cb36ef0a8d 100644
--- a/src/window.h
+++ b/src/window.h
@@ -27,7 +27,7 @@ All windows in use are arranged into a tree, with pointers up and down.
 Windows that are leaves of the tree are actually displayed
 and show the contents of buffers.  Windows that are not leaves
 are used for representing the way groups of leaf windows are
-arranged on the screen.  Leaf windows never become non-leaves.
+arranged on the frame.  Leaf windows never become non-leaves.
 They are deleted only by calling delete-window on them (but
 this can be done implicitly).  Combination windows can be created
 and deleted at any time.
@@ -38,7 +38,7 @@ A leaf window has a non-nil buffer field, and also
 
 Non-leaf windows are either vertical or horizontal combinations.
 
-A vertical combination window has children that are arranged on the screen
+A vertical combination window has children that are arranged on the frame
 one above the next.  Its vchild field points to the uppermost child.
 The parent field of each of the children points to the vertical
 combination window.  The next field of each child points to the
@@ -57,7 +57,7 @@ combination window may be leaf windows or vertical combination windows.
 
 At the top of the tree are two windows which have nil as parent.
 The second of these is minibuf_window.  The first one manages all
-the screen area that is not minibuffer, and is called the root window.
+the frame area that is not minibuffer, and is called the root window.
 Different windows can be the root at different times;
 initially the root window is a leaf window, but if more windows
 are created then that leaf window ceases to be root and a newly
@@ -75,8 +75,8 @@ struct window
     /* The window code does not refer to them.  */
     int size;
     struct Lisp_Vector *vec_next;
-    /* The screen this window is on.  */
-    Lisp_Object screen;
+    /* The frame this window is on.  */
+    Lisp_Object frame;
     /* t if this window is a minibuffer window.  */
     Lisp_Object mini_p;
     /* Following child (to right or down) at same level of tree */
@@ -90,7 +90,7 @@ struct window
     /* The window this one is a child of. */
     Lisp_Object parent;
     /* The upper left corner coordinates of this window,
-       as integers relative to upper left corner of screen = 0, 0 */
+       as integers relative to upper left corner of frame = 0, 0 */
     Lisp_Object left;
     Lisp_Object top;
     /* The size of the window */
@@ -122,11 +122,11 @@ struct window
     /* Value of point at that time */
     Lisp_Object last_point;
 /* The rest are currently not used or only half used */
-    /* Screen coords of point at that time */
+    /* Frame coords of point at that time */
     Lisp_Object last_point_x;
     Lisp_Object last_point_y;
-    /* Screen coords of mark as of last time display completed */
-    /* May be nil if mark does not exist or was not on screen */
+    /* Frame coords of mark as of last time display completed */
+    /* May be nil if mark does not exist or was not on frame */
     Lisp_Object last_mark_x;
     Lisp_Object last_mark_y;
     /* Number of characters in buffer past bottom of window,
@@ -134,8 +134,8 @@ struct window
     Lisp_Object window_end_pos;
     /* t if window_end_pos is truly valid.
        This is nil if nontrivial redisplay is preempted
-       since in that case the screen image that window_end_pos
-       did not get onto the screen.  */
+       since in that case the frame image that window_end_pos
+       did not get onto the frame.  */
     Lisp_Object window_end_valid;
     /* Vertical position (relative to window top) of that buffer position
        of the first of those characters */
@@ -162,17 +162,17 @@ struct window
    the top level editing loop at the end of each command.
 
    This value is always the same as
-    SCREEN_SELECTED_WINDOW (selected_screen).  */
+    FRAME_SELECTED_WINDOW (selected_frame).  */
 
 extern Lisp_Object selected_window;
 
 /* This is a time stamp for window selection, so we can find the least
    recently used window.  Its only users are Fselect_window,
-   init_window_once, and make_screen.  */
+   init_window_once, and make_frame.  */
 
 extern int window_select_count;
 
-/* The minibuffer window of the selected screen.
+/* The minibuffer window of the selected frame.
    Note that you cannot test for minibufferness of an arbitrary window
    by comparing against this; but you can test for minibufferness of
    the selected window or of any window that is displayed.  */
diff --git a/src/xdisp.c b/src/xdisp.c
index 2808c515d47..3b23c489a95 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -23,7 +23,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 /*#include <ctype.h>*/
 #undef NULL
 #include "lisp.h"
-#include "screen.h"
+#include "frame.h"
 #include "window.h"
 #include "termchar.h"
 #include "dispextern.h"
@@ -44,18 +44,18 @@ int noninteractive_need_newline;
 #define max(a, b) ((a) > (b) ? (a) : (b))
 
 /* The buffer position of the first character appearing
- entirely or partially on the current screen line.
- Or zero, which disables the optimization for the current screen line. */
+ entirely or partially on the current frame line.
+ Or zero, which disables the optimization for the current frame line. */
 static int this_line_bufpos;
 
 /* Number of characters past the end of this line,
    including the terminating newline */
 static int this_line_endpos;
 
-/* The vertical position of this screen line. */
+/* The vertical position of this frame line. */
 static int this_line_vpos;
 
-/* Hpos value for start of display on this screen line.
+/* Hpos value for start of display on this frame line.
    Usually zero, but negative if first character really began
    on previous line */
 static int this_line_start_hpos;
@@ -64,17 +64,17 @@ static int this_line_start_hpos;
 static struct buffer *this_line_buffer;
 
 /* Set by try_window_id to the vpos of first of any lines
-   scrolled on to the bottom of the screen.  These lines should
+   scrolled on to the bottom of the frame.  These lines should
    not be included in any general scroll computation.  */
 static int scroll_bottom_vpos;
 
 /* Value of echo_area_glyphs when it was last acted on.
-  If this is nonzero, there is a message on the screen
+  If this is nonzero, there is a message on the frame
   in the minibuffer and it should be erased as soon
   as it is no longer requested to appear. */
 char *previous_echo_glyphs;
 
-/* Nonzero means truncate lines in all windows less wide than the screen */
+/* Nonzero means truncate lines in all windows less wide than the frame */
 int truncate_partial_width_windows;
 
 Lisp_Object Vglobal_mode_string;
@@ -91,7 +91,7 @@ Lisp_Object last_arrow_position, last_arrow_string;
 /* Nonzero if overlay arrow has been displayed once in this window.  */
 static int overlay_arrow_seen;
 
-/* If cursor motion alone moves point off screen,
+/* If cursor motion alone moves point off frame,
    Try scrolling this many lines up or down if that will bring it back.  */
 int scroll_step;
 
@@ -103,7 +103,7 @@ static int blank_end_of_window;
    keyboard.c refers to this.  */
 int buffer_shared;
 
-/* display_text_line sets these to the screen position (origin 0) of point,
+/* display_text_line sets these to the frame position (origin 0) of point,
    whether the window is selected or not.
    Set one to -1 first to determine whether point was found afterwards.  */
 
@@ -167,7 +167,7 @@ int clip_changed;
 int windows_or_buffers_changed;
 
 
-/* Nonzero if SCREEN_MESSAGE_BUF (selected_screen) is being used by print;
+/* Nonzero if FRAME_MESSAGE_BUF (selected_frame) is being used by print;
    zero if being used by message.  */
 int message_buf_print;
 
@@ -187,14 +187,14 @@ message (m, a1, a2, a3)
       fprintf (stderr, "\n");
       fflush (stderr);
     }
-  /* A null message buffer means that the screen hasn't really been
+  /* A null message buffer means that the frame hasn't really been
      initialized yet.  Error messages get reported properly by
      cmd_error, so this must be just an informative message; toss it.  */
-  else if (INTERACTIVE && SCREEN_MESSAGE_BUF (selected_screen))
+  else if (INTERACTIVE && FRAME_MESSAGE_BUF (selected_frame))
     {
-#ifdef MULTI_SCREEN
-      choose_minibuf_screen ();
-      Fmake_screen_visible (WINDOW_SCREEN (XWINDOW (minibuf_window)));
+#ifdef MULTI_FRAME
+      choose_minibuf_frame ();
+      Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window)));
 #endif
 
       {
@@ -204,15 +204,15 @@ message (m, a1, a2, a3)
         a[1] = a2;
         a[2] = a3;
 
-        doprnt (SCREEN_MESSAGE_BUF (selected_screen),
-                SCREEN_WIDTH (selected_screen), m, 0, 3, a);
+        doprnt (FRAME_MESSAGE_BUF (selected_frame),
+                FRAME_WIDTH (selected_frame), m, 0, 3, a);
 #else
-        doprnt (SCREEN_MESSAGE_BUF (selected_screen),
-                SCREEN_WIDTH (selected_screen), m, 0, 3, &a1);
+        doprnt (FRAME_MESSAGE_BUF (selected_frame),
+                FRAME_WIDTH (selected_frame), m, 0, 3, &a1);
 #endif                          /* NO_ARG_ARRAY */
       }
 
-      echo_area_glyphs = SCREEN_MESSAGE_BUF (selected_screen);
+      echo_area_glyphs = FRAME_MESSAGE_BUF (selected_frame);
 
       /* Print should start at the beginning of the message
          buffer next time.  */
@@ -220,7 +220,7 @@ message (m, a1, a2, a3)
 
       do_pending_window_change ();
       echo_area_display ();
-      update_screen (XSCREEN (XWINDOW (minibuf_window)->screen), 1, 1);
+      update_frame (XFRAME (XWINDOW (minibuf_window)->frame), 1, 1);
       do_pending_window_change ();
     }
 }
@@ -238,20 +238,20 @@ message1 (m)
       fprintf (stderr, "%s\n", m);
       fflush (stderr);
     }
-  /* A null message buffer means that the screen hasn't really been
+  /* A null message buffer means that the frame hasn't really been
      initialized yet.  Error messages get reported properly by
      cmd_error, so this must be just an informative message; toss it.  */
-  else if (INTERACTIVE && SCREEN_MESSAGE_BUF (selected_screen))
+  else if (INTERACTIVE && FRAME_MESSAGE_BUF (selected_frame))
     {
-#ifdef MULTI_SCREEN
-      choose_minibuf_screen ();
-      Fmake_screen_visible (WINDOW_SCREEN (XWINDOW (minibuf_window)));
+#ifdef MULTI_FRAME
+      choose_minibuf_frame ();
+      Fmake_frame_visible (WINDOW_FRAME (XWINDOW (minibuf_window)));
 #endif
 
       echo_area_glyphs = m;
       do_pending_window_change ();
       echo_area_display ();
-      update_screen (XSCREEN (XWINDOW (minibuf_window)->screen), 1, 1);
+      update_frame (XFRAME (XWINDOW (minibuf_window)->frame), 1, 1);
       do_pending_window_change ();
     }
 }
@@ -260,33 +260,33 @@ static void
 echo_area_display ()
 {
   register int vpos;
-  SCREEN_PTR s;
+  FRAME_PTR f;
 
-#ifdef MULTI_SCREEN
-  choose_minibuf_screen ();
-  s = XSCREEN (WINDOW_SCREEN (XWINDOW (minibuf_window)));
+#ifdef MULTI_FRAME
+  choose_minibuf_frame ();
+  f = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
 
-  if (! SCREEN_VISIBLE_P (s))
+  if (! FRAME_VISIBLE_P (f))
     return;
 #endif
 
-  if (screen_garbaged)
+  if (frame_garbaged)
     {
       Fredraw_display ();
-      screen_garbaged = 0;
+      frame_garbaged = 0;
     }
 
   if (echo_area_glyphs || minibuf_level == 0)
     {
       vpos = XFASTINT (XWINDOW (minibuf_window)->top);
-      get_display_line (s, vpos, 0);
+      get_display_line (f, vpos, 0);
       display_string (XWINDOW (minibuf_window), vpos,
                       echo_area_glyphs ? echo_area_glyphs : "",
-                      0, 0, 0, SCREEN_WIDTH (s));
+                      0, 0, 0, FRAME_WIDTH (f));
 
       /* If desired cursor location is on this line, put it at end of text */
-      if (SCREEN_CURSOR_Y (s) == vpos)
-        SCREEN_CURSOR_X (s) = SCREEN_DESIRED_GLYPHS (s)->used[vpos];
+      if (FRAME_CURSOR_Y (f) == vpos)
+        FRAME_CURSOR_X (f) = FRAME_DESIRED_GLYPHS (f)->used[vpos];
 
       /* Fill the rest of the minibuffer window with blank lines.  */
       {
@@ -294,9 +294,9 @@ echo_area_display ()
 
         for (i = vpos + 1; i < vpos + XWINDOW (minibuf_window)->height; i++)
           {
-            get_display_line (s, i, 0);
+            get_display_line (f, i, 0);
             display_string (XWINDOW (minibuf_window), vpos,
-                            "", 0, 0, 0, SCREEN_WIDTH (s));
+                            "", 0, 0, 0, FRAME_WIDTH (f));
           }
       }
     }
@@ -309,7 +309,7 @@ echo_area_display ()
   previous_echo_glyphs = echo_area_glyphs;
 }
 
-/* Do a screen update, taking possible shortcuts into account.
+/* Do a frame update, taking possible shortcuts into account.
    This is the main external entry point for redisplay.
 
    If the last redisplay displayed an echo area message and that
@@ -338,17 +338,17 @@ redisplay ()
   if (noninteractive)
     return;
 
-  /* Notice any pending interrupt request to change screen size.  */
+  /* Notice any pending interrupt request to change frame size.  */
   do_pending_window_change ();
 
-  if (screen_garbaged)
+  if (frame_garbaged)
     {
       Fredraw_display ();
-      screen_garbaged = 0;
+      frame_garbaged = 0;
     }
 
   /* Normally the message* functions will have already displayed and
-     updated the echo area, but the screen may have been trashed, or
+     updated the echo area, but the frame may have been trashed, or
      the update may have been preempted, so display the echo area
      again here.  */
   if (echo_area_glyphs || previous_echo_glyphs)
@@ -369,7 +369,7 @@ redisplay ()
         update_mode_lines++;
     }
 
-  SCREEN_SCROLL_BOTTOM_VPOS (XSCREEN (w->screen)) = -1;
+  FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w->frame)) = -1;
 
   all_windows = update_mode_lines || buffer_shared > 1;
 
@@ -382,7 +382,7 @@ redisplay ()
   tlbufpos = this_line_bufpos;
   tlendpos = this_line_endpos;
   if (!all_windows && tlbufpos > 0 && NILP (w->update_mode_line)
-      && SCREEN_VISIBLE_P (XSCREEN (w->screen))
+      && FRAME_VISIBLE_P (XFRAME (w->frame))
       /* Make sure recorded data applies to current buffer, etc */
       && this_line_buffer == current_buffer
       && current_buffer == XBUFFER (w->buffer)
@@ -422,7 +422,7 @@ redisplay ()
           if (cursor_vpos >= 0 && this_line_bufpos
               && this_line_endpos == tlendpos)
             {
-              if (XFASTINT (w->width) != SCREEN_WIDTH (XSCREEN (WINDOW_SCREEN (w))))
+              if (XFASTINT (w->width) != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w))))
                 preserve_other_columns (w);
               goto update;
             }
@@ -445,14 +445,14 @@ redisplay ()
                                  point, 2, - (1 << (SHORTBITS - 1)),
                                  XFASTINT (w->width) - 1
                                  - (XFASTINT (w->width) + XFASTINT (w->left)
-                                    != SCREEN_WIDTH (selected_screen)),
+                                    != FRAME_WIDTH (selected_frame)),
                                  XINT (w->hscroll),
                                  pos_tab_offset (w, tlbufpos));
           if (pos.vpos < 1)
             {
-              SCREEN_CURSOR_X (selected_screen)
+              FRAME_CURSOR_X (selected_frame)
                 = XFASTINT (w->left) + max (pos.hpos, 0);
-              SCREEN_CURSOR_Y (selected_screen) = this_line_vpos;
+              FRAME_CURSOR_Y (selected_frame) = this_line_vpos;
               goto update;
             }
           else
@@ -460,7 +460,7 @@ redisplay ()
         }
     cancel:
       /* Text changed drastically or point moved off of line */
-      cancel_line (this_line_vpos, selected_screen);
+      cancel_line (this_line_vpos, selected_frame);
     }
 
   this_line_bufpos = 0;
@@ -468,33 +468,33 @@ redisplay ()
 
   if (all_windows)
     {
-#ifdef MULTI_SCREEN
+#ifdef MULTI_FRAME
       Lisp_Object tail;
 
       /* Recompute # windows showing selected buffer.
          This will be incremented each time such a window is displayed.  */
       buffer_shared = 0;
 
-      for (tail = Vscreen_list; CONSP (tail); tail = XCONS (tail)->cdr)
+      for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
         {
-          SCREEN_PTR s;
+          FRAME_PTR f;
 
-          if (XTYPE (XCONS (tail)->car) != Lisp_Screen)
+          if (XTYPE (XCONS (tail)->car) != Lisp_Frame)
             continue;
 
-          s = XSCREEN (XCONS (tail)->car);
-          if (s->visible)
+          f = XFRAME (XCONS (tail)->car);
+          if (f->visible)
             /* Redraw its windows.  */
-            redisplay_windows (SCREEN_ROOT_WINDOW (s));
+            redisplay_windows (FRAME_ROOT_WINDOW (f));
         }
 #else
-    redisplay_windows (SCREEN_ROOT_WINDOW (s));
-#endif /* not MULTI_SCREEN */
+    redisplay_windows (FRAME_ROOT_WINDOW (f));
+#endif /* not MULTI_FRAME */
     }
-  else if (SCREEN_VISIBLE_P (selected_screen))
+  else if (FRAME_VISIBLE_P (selected_frame))
     {
       redisplay_window (selected_window, 1);
-      if (XFASTINT (w->width) != SCREEN_WIDTH (selected_screen))
+      if (XFASTINT (w->width) != FRAME_WIDTH (selected_frame))
         preserve_other_columns (w);
     }
 
@@ -506,51 +506,51 @@ update:
     unrequest_sigio ();
   stop_polling ();
 
-#ifdef MULTI_SCREEN
+#ifdef MULTI_FRAME
   if (all_windows)
     {
       Lisp_Object tail;
 
       pause = 0;
 
-      for (tail = Vscreen_list; CONSP (tail); tail = XCONS (tail)->cdr)
+      for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
         {
-          SCREEN_PTR s;
+          FRAME_PTR f;
 
-          if (XTYPE (XCONS (tail)->car) != Lisp_Screen)
+          if (XTYPE (XCONS (tail)->car) != Lisp_Frame)
             continue;
 
-          s = XSCREEN (XCONS (tail)->car);
-          if (s->visible)
+          f = XFRAME (XCONS (tail)->car);
+          if (f->visible)
             {
-              pause |= update_screen (s, 0, 0);
+              pause |= update_frame (f, 0, 0);
               if (!pause)
-                mark_window_display_accurate (s->root_window, 1);
+                mark_window_display_accurate (f->root_window, 1);
             }
         }
     }
   else
-#endif /* MULTI_SCREEN */
+#endif /* MULTI_FRAME */
     {
-      if (SCREEN_VISIBLE_P (selected_screen))
-        pause = update_screen (selected_screen, 0, 0);
-#ifdef MULTI_SCREEN
+      if (FRAME_VISIBLE_P (selected_frame))
+        pause = update_frame (selected_frame, 0, 0);
+#ifdef MULTI_FRAME
       /* We may have called echo_area_display at the top of this
-         function.  If the echo area is on another screen, that may
-         have put text on a screen other than the selected one, so the
-         above call to update_screen would not have caught it.  Catch
+         function.  If the echo area is on another frame, that may
+         have put text on a frame other than the selected one, so the
+         above call to update_frame would not have caught it.  Catch
          it here.  */
       {
-        SCREEN_PTR mini_screen =
-          XSCREEN (WINDOW_SCREEN (XWINDOW (minibuf_window)));
+        FRAME_PTR mini_frame =
+          XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
         
-        if (mini_screen != selected_screen)
-          pause |= update_screen (mini_screen, 0, 0);
+        if (mini_frame != selected_frame)
+          pause |= update_frame (mini_frame, 0, 0);
       }
 #endif
     }
 
-  /* If screen does not match, prevent doing single-line-update next time.
+  /* If frame does not match, prevent doing single-line-update next time.
      Also, don't forget to check every line to update the arrow.  */
   if (pause)
     {
@@ -560,15 +560,15 @@ update:
           last_arrow_position = Qt;
           last_arrow_string = Qt;
         }
-      /* If we pause after scrolling, some lines in current_screen
+      /* If we pause after scrolling, some lines in current_frame
          may be null, so preserve_other_columns won't be able to
          preserve all the vertical-bar separators.  So, avoid using it
          in that case.  */
-      if (XFASTINT (w->width) != SCREEN_WIDTH (selected_screen))
+      if (XFASTINT (w->width) != FRAME_WIDTH (selected_frame))
         update_mode_lines = 1;
     }
 
-  /* Now text on screen agrees with windows, so
+  /* Now text on frame agrees with windows, so
      put info into the windows for partial redisplay to follow */
 
   if (!pause)
@@ -582,8 +582,8 @@ update:
       end_unchanged = BUF_Z (b) - BUF_GPT (b);
 
       XFASTINT (w->last_point) = BUF_PT (b);
-      XFASTINT (w->last_point_x) = SCREEN_CURSOR_X (selected_screen);
-      XFASTINT (w->last_point_y) = SCREEN_CURSOR_Y (selected_screen);
+      XFASTINT (w->last_point_x) = FRAME_CURSOR_X (selected_frame);
+      XFASTINT (w->last_point_y) = FRAME_CURSOR_Y (selected_frame);
 
       if (all_windows)
         mark_window_display_accurate (XWINDOW (minibuf_window)->prev, 1);
@@ -610,7 +610,7 @@ update:
     request_sigio ();
   start_polling ();
 
-  /* Change screen size now if a change is pending.  */
+  /* Change frame size now if a change is pending.  */
   do_pending_window_change ();
 }
 
@@ -688,13 +688,13 @@ redisplay_window (window, just_this_one)
      int just_this_one;
 {
   register struct window *w = XWINDOW (window);
-  SCREEN_PTR s = XSCREEN (w->screen);
+  FRAME_PTR f = XFRAME (w->frame);
   int height;
   register int lpoint = point;
   struct buffer *old = current_buffer;
   register int width = XFASTINT (w->width) - 1
     - (XFASTINT (w->width) + XFASTINT (w->left)
-       != SCREEN_WIDTH (XSCREEN (WINDOW_SCREEN (w))));
+       != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w))));
   register int startp;
   register int hscroll = XINT (w->hscroll);
   struct position pos;
@@ -702,7 +702,7 @@ redisplay_window (window, just_this_one)
   int tem;
   int window_needs_modeline;
 
-  if (SCREEN_HEIGHT (s) == 0) abort (); /* Some bug zeros some core */
+  if (FRAME_HEIGHT (f) == 0) abort (); /* Some bug zeros some core */
 
   /* If this is a combination window, do its children; that's all.  */
 
@@ -733,12 +733,12 @@ redisplay_window (window, just_this_one)
         {
           /* This is a minibuffer, but it's not the currently active one, so
              clear it.  */
-          int vpos = XFASTINT (XWINDOW (SCREEN_MINIBUF_WINDOW (s))->top);
+          int vpos = XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top);
           int i;
 
           for (i = 0; i < height; i++)
             {
-              get_display_line (s, vpos + i, 0);
+              get_display_line (f, vpos + i, 0);
               display_string (w, vpos + i, "", 0, 0, 0, width);
             }
           
@@ -806,20 +806,20 @@ redisplay_window (window, just_this_one)
                                 - (1 << (SHORTBITS - 1)),
                                 width, hscroll, pos_tab_offset (w, startp));
           SET_PT (pos.bufpos);
-          if (w != XWINDOW (SCREEN_SELECTED_WINDOW (s)))
+          if (w != XWINDOW (FRAME_SELECTED_WINDOW (f)))
             Fset_marker (w->pointm, make_number (point), Qnil);
           else
             {
               lpoint = point;
-              SCREEN_CURSOR_X (s) = max (0, pos.hpos) + XFASTINT (w->left);
-              SCREEN_CURSOR_Y (s) = pos.vpos + XFASTINT (w->top);
+              FRAME_CURSOR_X (f) = max (0, pos.hpos) + XFASTINT (w->left);
+              FRAME_CURSOR_Y (f) = pos.vpos + XFASTINT (w->top);
             }
         }
       goto done;
     }
 
   /* Handle case where text has not changed, only point,
-     and it has not moved off the screen */
+     and it has not moved off the frame */
 
   /* This code is not used for minibuffer for the sake of
      the case of redisplaying to replace an echo area message;
@@ -830,7 +830,7 @@ redisplay_window (window, just_this_one)
 
   if (XFASTINT (w->last_modified) >= MODIFF
       && point >= startp && !clip_changed
-      && (just_this_one || XFASTINT (w->width) == SCREEN_WIDTH (s))
+      && (just_this_one || XFASTINT (w->width) == FRAME_WIDTH (f))
       && !EQ (window, minibuf_window))
     {
       pos = *compute_motion (startp, 0, (hscroll ? 1 - hscroll : 0),
@@ -839,18 +839,18 @@ redisplay_window (window, just_this_one)
 
       if (pos.vpos < height)
         {
-          /* Ok, point is still on screen */
-          if (w == XWINDOW (SCREEN_SELECTED_WINDOW (s)))
+          /* Ok, point is still on frame */
+          if (w == XWINDOW (FRAME_SELECTED_WINDOW (f)))
             {
               /* These variables are supposed to be origin 1 */
-              SCREEN_CURSOR_X (s) = max (0, pos.hpos) + XFASTINT (w->left);
-              SCREEN_CURSOR_Y (s) = pos.vpos + XFASTINT (w->top);
+              FRAME_CURSOR_X (f) = max (0, pos.hpos) + XFASTINT (w->left);
+              FRAME_CURSOR_Y (f) = pos.vpos + XFASTINT (w->top);
             }
           /* This doesn't do the trick, because if a window to the right of
              this one must be redisplayed, this does nothing because there
-             is nothing in DesiredScreen yet, and then the other window is
+             is nothing in DesiredFrame yet, and then the other window is
              redisplayed, making likes that are empty in this window's columns.
-             if (XFASTINT (w->width) != SCREEN_WIDTH (s))
+             if (XFASTINT (w->width) != FRAME_WIDTH (f))
              preserve_my_columns (w);
              */
           goto done;
@@ -872,10 +872,10 @@ redisplay_window (window, just_this_one)
            && ! EQ (w->window_end_valid, Qnil)
            && do_id && !clip_changed
            && !blank_end_of_window
-           && XFASTINT (w->width) == SCREEN_WIDTH (s)
+           && XFASTINT (w->width) == FRAME_WIDTH (f)
            && EQ (last_arrow_position, Voverlay_arrow_position)
            && EQ (last_arrow_string, Voverlay_arrow_string)
-           && (tem = try_window_id (SCREEN_SELECTED_WINDOW (s)))
+           && (tem = try_window_id (FRAME_SELECTED_WINDOW (f)))
            && tem != -2)
     {
       /* tem > 0 means success.  tem == -1 means choose new start.
@@ -891,7 +891,7 @@ redisplay_window (window, just_this_one)
                || (XFASTINT (w->last_modified) >= MODIFF)))
     {
       /* Try to redisplay starting at same place as before */
-      /* If point has not moved off screen, accept the results */
+      /* If point has not moved off frame, accept the results */
       try_window (window, startp);
       if (cursor_vpos >= 0)
         goto done;
@@ -942,7 +942,7 @@ done:
   /* If window not full width, must redo its mode line
      if the window to its side is being redone */
   if ((!NILP (w->update_mode_line)
-       || (!just_this_one && width < SCREEN_WIDTH (s) - 1))
+       || (!just_this_one && width < FRAME_WIDTH (f) - 1))
       && height != XFASTINT (w->height))
     display_mode_line (w);
 
@@ -963,9 +963,9 @@ try_window (window, pos)
   register int vpos = XFASTINT (w->top);
   register int last_text_vpos = vpos;
   int tab_offset = pos_tab_offset (w, pos);
-  SCREEN_PTR s = XSCREEN (w->screen);
+  FRAME_PTR f = XFRAME (w->frame);
   int width = XFASTINT (w->width) - 1
-    - (XFASTINT (w->width) + XFASTINT (w->left) != SCREEN_WIDTH (s));
+    - (XFASTINT (w->width) + XFASTINT (w->left) != FRAME_WIDTH (f));
   struct position val;
 
   Fset_marker (w->start, make_number (pos), Qnil);
@@ -987,16 +987,16 @@ try_window (window, pos)
     }
 
   /* If last line is continued in middle of character,
-     include the split character in the text considered on the screen */
+     include the split character in the text considered on the frame */
   if (val.hpos < (XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0))
     pos++;
 
-  /* If bottom just moved off end of screen, change mode line percentage.  */
+  /* If bottom just moved off end of frame, change mode line percentage.  */
   if (XFASTINT (w->window_end_pos) == 0
       && Z != pos)
     w->update_mode_line = Qt;
 
-  /* Say where last char on screen will be, once redisplay is finished.  */
+  /* Say where last char on frame will be, once redisplay is finished.  */
   XFASTINT (w->window_end_pos) = Z - pos;
   XFASTINT (w->window_end_vpos) = last_text_vpos - XFASTINT (w->top);
   /* But that is not valid info until redisplay finishes.  */
@@ -1017,11 +1017,11 @@ try_window_id (window)
   int pos;
   register struct window *w = XWINDOW (window);
   register int height = window_internal_height (w);
-  SCREEN_PTR s = XSCREEN (w->screen);
+  FRAME_PTR f = XFRAME (w->frame);
   int top = XFASTINT (w->top);
   int start = marker_position (w->start);
   int width = XFASTINT (w->width) - 1
-    - (XFASTINT (w->width) + XFASTINT (w->left) != SCREEN_WIDTH (s));
+    - (XFASTINT (w->width) + XFASTINT (w->left) != FRAME_WIDTH (f));
   int hscroll = XINT (w->hscroll);
   int lmargin = hscroll > 0 ? 1 - hscroll : 0;
   register int vpos;
@@ -1050,8 +1050,8 @@ try_window_id (window)
     {
       if (point < bp.bufpos && !bp.contin)
         {
-          /* All changes are below the screen, and point is on the screen.
-             We don't need to change the screen at all.
+          /* All changes are below the frame, and point is on the frame.
+             We don't need to change the frame at all.
              But we need to update window_end_pos to account for
              any change in buffer size.  */
           bp = *compute_motion (start, 0, lmargin,
@@ -1066,7 +1066,7 @@ try_window_id (window)
 
   vpos = bp.vpos;
 
-  /* Find beginning of that screen line.  Must display from there.  */
+  /* Find beginning of that frame line.  Must display from there.  */
   bp = *vmotion (bp.bufpos, 0, width, hscroll, window);
 
   pos = bp.bufpos;
@@ -1075,7 +1075,7 @@ try_window_id (window)
     return -1;
 
   /* If about to start displaying at the beginning of a continuation line,
-     really start with previous screen line, in case it was not
+     really start with previous frame line, in case it was not
      continued when last redisplayed */
   if ((bp.contin && bp.bufpos - 1 == beg_unchanged && vpos > 0)
       ||
@@ -1111,8 +1111,8 @@ try_window_id (window)
                         height, - (1 << (SHORTBITS - 1)),
                         width, hscroll, pos_tab_offset (w, bp.bufpos));
 
-  /* If changes reach past the text available on the screen,
-     just display rest of screen.  */
+  /* If changes reach past the text available on the frame,
+     just display rest of frame.  */
   if (ep.bufpos > Z - XFASTINT (w->window_end_pos))
     stop_vpos = height;
   else
@@ -1143,7 +1143,7 @@ try_window_id (window)
                             10000, 0, width, hscroll, epto);
       scroll_amount = xp.vpos - XFASTINT (w->window_end_vpos);
 
-      /* Is everything on screen below the changes whitespace?
+      /* Is everything on frame below the changes whitespace?
          If so, no scrolling is really necessary.  */
       for (i = ep.bufpos; i < xp.bufpos; i++)
         {
@@ -1156,7 +1156,7 @@ try_window_id (window)
 
       XFASTINT (w->window_end_vpos) += scroll_amount;
 
-      /* Before doing any scrolling, verify that point will be on screen. */
+      /* Before doing any scrolling, verify that point will be on frame. */
       if (point > ep.bufpos && !(point <= xp.bufpos && xp.bufpos < height))
         {
           if (point <= xp.bufpos)
@@ -1186,9 +1186,9 @@ try_window_id (window)
           /* In this path, we have altered window_end_vpos
              and not left it negative.
              We must make sure that, in case display is preempted
-             before the screen changes to reflect what we do here,
+             before the frame changes to reflect what we do here,
              further updates will not come to try_window_id
-             and assume the screen and window_end_vpos match.  */
+             and assume the frame and window_end_vpos match.  */
           blank_end_of_window = 1;
         }
       else if (!scroll_amount)
@@ -1197,7 +1197,7 @@ try_window_id (window)
         {
           /* If reprinting everything is nearly as fast as scrolling,
              don't bother scrolling.  Can happen if lines are short.  */
-          if (scroll_cost (s, bp.vpos + top - scroll_amount,
+          if (scroll_cost (f, bp.vpos + top - scroll_amount,
                            top + height - max (0, scroll_amount),
                            scroll_amount)
               > xp.bufpos - bp.bufpos - 20)
@@ -1208,7 +1208,7 @@ try_window_id (window)
              In common case of killing a line, this can save the
              following line from being overwritten by scrolling
              and therefore having to be redrawn.  */
-          tem = scroll_screen_lines (s, bp.vpos + top - scroll_amount,
+          tem = scroll_frame_lines (f, bp.vpos + top - scroll_amount,
                                      top + height - max (0, scroll_amount),
                                      scroll_amount);
           if (!tem) stop_vpos = height;
@@ -1220,14 +1220,14 @@ try_window_id (window)
           /* Note that if scroll_amount > 0, xp.bufpos - bp.bufpos is an
              overestimate of cost of reprinting, since xp.bufpos
              would end up below the bottom of the window.  */
-          if (scroll_cost (s, ep.vpos + top - scroll_amount,
+          if (scroll_cost (f, ep.vpos + top - scroll_amount,
                            top + height - max (0, scroll_amount),
                            scroll_amount)
               > xp.bufpos - ep.bufpos - 20)
             /* Return "try normal display with same window-start."
                Too bad we can't prevent further scroll-thinking.  */
             return -2;
-          tem = scroll_screen_lines (s, ep.vpos + top - scroll_amount,
+          tem = scroll_frame_lines (f, ep.vpos + top - scroll_amount,
                                      top + height - max (0, scroll_amount),
                                      scroll_amount);
           if (!tem) stop_vpos = height;
@@ -1272,7 +1272,7 @@ try_window_id (window)
   if (vpos == height)
     {
       /* If last line is continued in middle of character,
-         include the split character in the text considered on the screen */
+         include the split character in the text considered on the frame */
       if (val.hpos < lmargin)
         val.bufpos++;
       XFASTINT (w->window_end_vpos) = last_text_vpos;
@@ -1285,7 +1285,7 @@ try_window_id (window)
     {
       /* Don't consider these lines for general-purpose scrolling.
          That will save time in the scrolling computation.  */
-      SCREEN_SCROLL_BOTTOM_VPOS (s) = xp.vpos;
+      FRAME_SCROLL_BOTTOM_VPOS (f) = xp.vpos;
       vpos = xp.vpos;
       pos = xp.bufpos;
       val.hpos = lmargin;
@@ -1319,7 +1319,7 @@ try_window_id (window)
         cursor_vpos = -1;
     }
 
-  /* If bottom just moved off end of screen, change mode line percentage.  */
+  /* If bottom just moved off end of frame, change mode line percentage.  */
   if (XFASTINT (w->window_end_pos) == 0
       && Z != val.bufpos)
     w->update_mode_line = Qt;
@@ -1346,19 +1346,19 @@ try_window_id (window)
     {
       val = *compute_motion (start, 0, lmargin, point, 10000, 10000,
                              width, hscroll, pos_tab_offset (w, start));
-      /* Admit failure if point is off screen now */
+      /* Admit failure if point is off frame now */
       if (val.vpos >= height)
         {
           for (vpos = 0; vpos < height; vpos++)
-            cancel_line (vpos + top, s);
+            cancel_line (vpos + top, f);
           return 0;
         }
       cursor_vpos = val.vpos + top;
       cursor_hpos = val.hpos + XFASTINT (w->left);
     }
 
-  SCREEN_CURSOR_X (s) = max (0, cursor_hpos);
-  SCREEN_CURSOR_Y (s) = cursor_vpos;
+  FRAME_CURSOR_X (f) = max (0, cursor_hpos);
+  FRAME_CURSOR_Y (f) = cursor_vpos;
 
   if (debug_end_pos)
     {
@@ -1408,7 +1408,7 @@ copy_rope (t, s, from)
 
    TABOFFSET is an offset for ostensible hpos, used in tab stop calculations.
 
-   Display on position VPOS on the screen.  (origin 0).
+   Display on position VPOS on the frame.  (origin 0).
 
    Returns a STRUCT POSITION giving character to start next line with
    and where to display it, including a zero or negative hpos.
@@ -1433,18 +1433,18 @@ display_text_line (w, start, vpos, hpos, taboffset)
   GLYPH *endp;
   register GLYPH *startp;
   register GLYPH *p1prev;
-  SCREEN_PTR s = XSCREEN (w->screen);
+  FRAME_PTR f = XFRAME (w->frame);
   int tab_width = XINT (current_buffer->tab_width);
   int ctl_arrow = !NILP (current_buffer->ctl_arrow);
   int width = XFASTINT (w->width) - 1
-    - (XFASTINT (w->width) + XFASTINT (w->left) != SCREEN_WIDTH (s));
+    - (XFASTINT (w->width) + XFASTINT (w->left) != FRAME_WIDTH (f));
   struct position val;
   int lastpos;
   int invis;
   int hscroll = XINT (w->hscroll);
   int truncate = hscroll
     || (truncate_partial_width_windows
-        && XFASTINT (w->width) < SCREEN_WIDTH (s))
+        && XFASTINT (w->width) < FRAME_WIDTH (f))
     || !NILP (current_buffer->truncate_lines);
   int selective
     = XTYPE (current_buffer->selective_display) == Lisp_Int
@@ -1453,7 +1453,7 @@ display_text_line (w, start, vpos, hpos, taboffset)
 #ifndef old
   int selective_e = selective && !NILP (current_buffer->selective_display_ellipses);
 #endif
-  register struct screen_glyphs *desired_glyphs = SCREEN_DESIRED_GLYPHS (s);
+  register struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (f);
   register struct Lisp_Vector *dp = window_display_table (w);
   int selective_rlen
     = (selective && dp && XTYPE (DISP_INVIS_ROPE (dp)) == Lisp_String
@@ -1464,7 +1464,7 @@ display_text_line (w, start, vpos, hpos, taboffset)
                     ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp)));
 
   hpos += XFASTINT (w->left);
-  get_display_line (s, vpos, XFASTINT (w->left));
+  get_display_line (f, vpos, XFASTINT (w->left));
   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
 
   if (MINI_WINDOW_P (w) && start == 1
@@ -1652,7 +1652,7 @@ display_text_line (w, start, vpos, hpos, taboffset)
     }
 
   /* If point is at eol or in invisible text at eol,
-     record its screen location now.  */
+     record its frame location now.  */
 
   if (start <= point && point <= lastpos && cursor_vpos < 0)
     {
@@ -1665,10 +1665,10 @@ display_text_line (w, start, vpos, hpos, taboffset)
       if (cursor_hpos < 0) cursor_hpos = 0;
       if (cursor_hpos > width) cursor_hpos = width;
       cursor_hpos += XFASTINT (w->left);
-      if (w == XWINDOW (SCREEN_SELECTED_WINDOW (s)))
+      if (w == XWINDOW (FRAME_SELECTED_WINDOW (f)))
         {
-          SCREEN_CURSOR_Y (s) = cursor_vpos;
-          SCREEN_CURSOR_X (s) = cursor_hpos;
+          FRAME_CURSOR_Y (f) = cursor_vpos;
+          FRAME_CURSOR_X (f) = cursor_hpos;
 
           if (w == XWINDOW (selected_window))
             {
@@ -1698,7 +1698,7 @@ display_text_line (w, start, vpos, hpos, taboffset)
         p1 = startp + 1;
     }
 
-  if (XFASTINT (w->width) + XFASTINT (w->left) != SCREEN_WIDTH (s))
+  if (XFASTINT (w->width) + XFASTINT (w->left) != FRAME_WIDTH (f))
     {
       endp++;
       if (p1 < startp) p1 = startp;
@@ -1747,12 +1747,12 @@ display_mode_line (w)
   register int vpos = XFASTINT (w->height) + XFASTINT (w->top) - 1;
   register int left = XFASTINT (w->left);
   register int right = XFASTINT (w->width) + left;
-  register SCREEN_PTR s = XSCREEN (WINDOW_SCREEN (w));
+  register FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
 
-  get_display_line (s, vpos, left);
+  get_display_line (f, vpos, left);
   display_mode_element (w, vpos, left, 0, right, right,
                         current_buffer->mode_line_format);
-  SCREEN_DESIRED_GLYPHS (s)->bufp[vpos] = 0;
+  FRAME_DESIRED_GLYPHS (f)->bufp[vpos] = 0;
 
   /* Make the mode line inverse video if the entire line
      is made of mode lines.
@@ -1760,19 +1760,19 @@ display_mode_line (w)
      or if it is the child of a full width window
      (which implies that that window is split side-by-side
      and the rest of this line is mode lines of the sibling windows).  */
-  if (XFASTINT (w->width) == SCREEN_WIDTH (s)
-      || XFASTINT (XWINDOW (w->parent)->width) == SCREEN_WIDTH (s))
-    SCREEN_DESIRED_GLYPHS (s)->highlight[vpos] = mode_line_inverse_video;
+  if (XFASTINT (w->width) == FRAME_WIDTH (f)
+      || XFASTINT (XWINDOW (w->parent)->width) == FRAME_WIDTH (f))
+    FRAME_DESIRED_GLYPHS (f)->highlight[vpos] = mode_line_inverse_video;
 
 #ifdef HAVE_X_WINDOWS
   /* I'm trying this out because I saw Unimpress use it, but it's
      possible that this may mess adversely with some window managers.  jla */
 
-  if (SCREEN_IS_X (s)
-      && ! SCREEN_MINIBUF_ONLY_P (s)
-      && w == XWINDOW (s->selected_window)
-      && (NILP (Fstring_equal (XBUFFER (w->buffer)->name, s->name))))
-    x_set_name (s, XBUFFER (w->buffer)->name, Qnil);
+  if (FRAME_IS_X (f)
+      && ! FRAME_MINIBUF_ONLY_P (f)
+      && w == XWINDOW (f->selected_window)
+      && (NILP (Fstring_equal (XBUFFER (w->buffer)->name, f->name))))
+    x_set_name (f, XBUFFER (w->buffer)->name, Qnil);
 #endif
 }
 
@@ -1781,7 +1781,7 @@ display_mode_line (w)
 
    VPOS is the position of the mode line being displayed.
 
-   HPOS is the position (absolute on screen) where this element's text
+   HPOS is the position (absolute on frame) where this element's text
    should start.  The output is truncated automatically at the right
    edge of window W.
 
@@ -1994,11 +1994,11 @@ decode_mode_spec (w, c, maxwidth)
      register int maxwidth;
 {
   Lisp_Object obj = Qnil;
-  SCREEN_PTR scr = XSCREEN (WINDOW_SCREEN (w));
-  char *decode_mode_spec_buf = (char *) SCREEN_TEMP_GLYPHS (scr)->total_contents;
+  FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
+  char *decode_mode_spec_buf = (char *) FRAME_TEMP_GLYPHS (f)->total_contents;
 
-  if (maxwidth > SCREEN_WIDTH (scr))
-    maxwidth = SCREEN_WIDTH (scr);
+  if (maxwidth > FRAME_WIDTH (f))
+    maxwidth = FRAME_WIDTH (f);
 
   switch (c)
     {
@@ -2143,7 +2143,7 @@ decode_mode_spec (w, c, maxwidth)
   MINCOL is the first column ok to end at.  (Pad with spaces to this col.)
   MAXCOL is the last column ok to end at.  Truncate here.
     -1 for MINCOL or MAXCOL means no explicit minimum or maximum.
-  Both count from the left edge of the screen, as does HPOS.
+  Both count from the left edge of the frame, as does HPOS.
   The right edge of W is an implicit maximum.
   If TRUNCATE is nonzero, the implicit maximum is one column before the edge.
 
@@ -2163,7 +2163,7 @@ display_string (w, vpos, string, hpos, truncate, mincol, maxcol)
   int tab_width = XINT (current_buffer->tab_width);
   register GLYPH *start;
   register GLYPH *end;
-  struct screen_glyphs *desired_glyphs = SCREEN_DESIRED_GLYPHS (XSCREEN (w->screen));
+  struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (XFRAME (w->frame));
   GLYPH *p1start = desired_glyphs->glyphs[vpos] + hpos;
   int window_width = XFASTINT (w->width);
 
@@ -2182,7 +2182,7 @@ display_string (w, vpos, string, hpos, truncate, mincol, maxcol)
   end = start + window_width - (truncate != 0);
 
   if ((window_width + XFASTINT (w->left))
-      != SCREEN_WIDTH (XSCREEN (WINDOW_SCREEN (w))))
+      != FRAME_WIDTH (XFRAME (WINDOW_FRAME (w))))
     *end-- = '|';
 
   if (maxcol >= 0 && end - desired_glyphs->glyphs[vpos] > maxcol)
@@ -2288,14 +2288,14 @@ See also `overlay-arrow-string'.");
 
   DEFVAR_INT ("scroll-step", &scroll_step,
     "*The number of lines to try scrolling a window by when point moves out.\n\
-If that fails to bring point back on screen, point is centered instead.\n\
-If this is zero, point is always centered after it moves off screen.");
+If that fails to bring point back on frame, point is centered instead.\n\
+If this is zero, point is always centered after it moves off frame.");
 
   DEFVAR_INT ("debug-end-pos", &debug_end_pos, "Don't ask");
 
   DEFVAR_BOOL ("truncate-partial-width-windows",
                &truncate_partial_width_windows,
-    "*Non-nil means truncate lines in all windows less than full screen wide.");
+    "*Non-nil means truncate lines in all windows less than full frame wide.");
   truncate_partial_width_windows = 1;
 
   DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video,
@@ -2322,13 +2322,13 @@ init_xdisp ()
 
   if (!noninteractive)
     {
-      SCREEN_PTR s = XSCREEN (WINDOW_SCREEN (XWINDOW (root_window)));
+      FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (root_window)));
       XFASTINT (XWINDOW (root_window)->top) = 0;
-      set_window_height (root_window, SCREEN_HEIGHT (s) - 1, 0);
-      XFASTINT (mini_w->top) = SCREEN_HEIGHT (s) - 1;
+      set_window_height (root_window, FRAME_HEIGHT (f) - 1, 0);
+      XFASTINT (mini_w->top) = FRAME_HEIGHT (f) - 1;
       set_window_height (minibuf_window, 1, 0);
 
-      XFASTINT (XWINDOW (root_window)->width) = SCREEN_WIDTH (s);
-      XFASTINT (mini_w->width) = SCREEN_WIDTH (s);
+      XFASTINT (XWINDOW (root_window)->width) = FRAME_WIDTH (f);
+      XFASTINT (mini_w->width) = FRAME_WIDTH (f);
     }
 }