*** empty log message ***

7 files changed, 970 insertions, 970 deletions

diff --git a/src/frame.c b/src/frame.c
index 1068c2e2e01..8482d1b3d14 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -1,4 +1,4 @@
-/* Generic screen functions.
+/* Generic frame functions.
    Copyright (C) 1989, 1992 Free Software Foundation.
 
 This file is part of GNU Emacs.
@@ -21,36 +21,36 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 #include "config.h"
 
-#ifdef MULTI_SCREEN
+#ifdef MULTI_FRAME
 
 #include "lisp.h"
-#include "screen.h"
+#include "frame.h"
 #include "window.h"
 #include "termhooks.h"
 
 Lisp_Object Vemacs_iconified;
-Lisp_Object Qscreenp;
-Lisp_Object Qlive_screen_p;
-Lisp_Object Vscreen_list;
-Lisp_Object Vterminal_screen;
-Lisp_Object Vdefault_minibuffer_screen;
-Lisp_Object Vdefault_screen_alist;
+Lisp_Object Qframep;
+Lisp_Object Qlive_frame_p;
+Lisp_Object Vframe_list;
+Lisp_Object Vterminal_frame;
+Lisp_Object Vdefault_minibuffer_frame;
+Lisp_Object Vdefault_frame_alist;
 Lisp_Object Qminibuffer;
 
 extern Lisp_Object Vminibuffer_list;
 extern Lisp_Object get_minibuffer ();
 
-DEFUN ("screenp", Fscreenp, Sscreenp, 1, 1, 0,
-  "Return non-nil if OBJECT is a screen.\n\
-Value is t for a termcap screen (a character-only terminal),\n\
-`x' for an Emacs screen that is really an X window.\n\
-Also see `live-screen-p'.")
+DEFUN ("framep", Fframep, Sframep, 1, 1, 0,
+  "Return non-nil if OBJECT is a frame.\n\
+Value is t for a termcap frame (a character-only terminal),\n\
+`x' for an Emacs frame that is really an X window.\n\
+Also see `live-frame-p'.")
   (object)
      Lisp_Object object;
 {
-  if (XTYPE (object) != Lisp_Screen)
+  if (XTYPE (object) != Lisp_Frame)
     return Qnil;
-  switch (XSCREEN (object)->output_method)
+  switch (XFRAME (object)->output_method)
     {
     case output_termcap:
       return Qt;
@@ -61,53 +61,53 @@ Also see `live-screen-p'.")
     }
 }
 
-DEFUN ("live-screen-p", Flive_screen_p, Slive_screen_p, 1, 1, 0,
-  "Return non-nil if OBJECT is a screen which has not been deleted.\n\
-Value is nil if OBJECT is not a live screen.  If object is a live\n\
-screen, the return value indicates what sort of output device it is\n\
-displayed on.  Value is t for a termcap screen (a character-only\n\
-terminal), `x' for an Emacs screen being displayed in an X window.")
+DEFUN ("live-frame-p", Flive_frame_p, Slive_frame_p, 1, 1, 0,
+  "Return non-nil if OBJECT is a frame which has not been deleted.\n\
+Value is nil if OBJECT is not a live frame.  If object is a live\n\
+frame, the return value indicates what sort of output device it is\n\
+displayed on.  Value is t for a termcap frame (a character-only\n\
+terminal), `x' for an Emacs frame being displayed in an X window.")
   (object)
      Lisp_Object object;
 {
-  return ((SCREENP (object)
-           && SCREEN_LIVE_P (XSCREEN (object)))
-          ? Fscreenp (object)
+  return ((FRAMEP (object)
+           && FRAME_LIVE_P (XFRAME (object)))
+          ? Fframep (object)
           : Qnil);
 }
 
-struct screen *
-make_screen (mini_p)
+struct frame *
+make_frame (mini_p)
      int mini_p;
 {
-  Lisp_Object screen;
-  register struct screen *s;
+  Lisp_Object frame;
+  register struct frame *f;
   register Lisp_Object root_window;
   register Lisp_Object mini_window;
 
-  screen = Fmake_vector (((sizeof (struct screen) - (sizeof (Lisp_Vector)
+  frame = Fmake_vector (((sizeof (struct frame) - (sizeof (Lisp_Vector)
                                                      - sizeof (Lisp_Object)))
                           / sizeof (Lisp_Object)),
                          make_number (0));
-  XSETTYPE (screen, Lisp_Screen);
-  s = XSCREEN (screen);
-
-  s->cursor_x = 0;
-  s->cursor_y = 0;
-  s->current_glyphs = 0;
-  s->desired_glyphs = 0;
-  s->visible = 0;
-  s->display.nothing = 0;
-  s->iconified = 0;
-  s->wants_modeline = 1;
-  s->auto_raise = 0;
-  s->auto_lower = 0;
-  s->no_split = 0;
-  s->garbaged = 0;
-  s->has_minibuffer = mini_p;
-  s->focus_screen = screen;
-
-  s->param_alist = Qnil;
+  XSETTYPE (frame, Lisp_Frame);
+  f = XFRAME (frame);
+
+  f->cursor_x = 0;
+  f->cursor_y = 0;
+  f->current_glyphs = 0;
+  f->desired_glyphs = 0;
+  f->visible = 0;
+  f->display.nothing = 0;
+  f->iconified = 0;
+  f->wants_modeline = 1;
+  f->auto_raise = 0;
+  f->auto_lower = 0;
+  f->no_split = 0;
+  f->garbaged = 0;
+  f->has_minibuffer = mini_p;
+  f->focus_frame = frame;
+
+  f->param_alist = Qnil;
 
   root_window = make_window (0);
   if (mini_p)
@@ -116,24 +116,24 @@ make_screen (mini_p)
       XWINDOW (root_window)->next = mini_window;
       XWINDOW (mini_window)->prev = root_window;
       XWINDOW (mini_window)->mini_p = Qt;
-      XWINDOW (mini_window)->screen = screen;
-      s->minibuffer_window = mini_window;
+      XWINDOW (mini_window)->frame = frame;
+      f->minibuffer_window = mini_window;
     }
   else
     {
       mini_window = Qnil;
       XWINDOW (root_window)->next = Qnil;
-      s->minibuffer_window = Qnil;
+      f->minibuffer_window = Qnil;
     }
 
-  XWINDOW (root_window)->screen = screen;
+  XWINDOW (root_window)->frame = frame;
 
   /* 10 is arbitrary,
      just so that there is "something there."
-     Correct size will be set up later with change_screen_size.  */
+     Correct size will be set up later with change_frame_size.  */
 
-  s->width = 10;
-  s->height = 10;
+  f->width = 10;
+  f->height = 10;
 
   XFASTINT (XWINDOW (root_window)->width) = 10;
   XFASTINT (XWINDOW (root_window)->height) = (mini_p ? 9 : 10);
@@ -145,7 +145,7 @@ make_screen (mini_p)
       XFASTINT (XWINDOW (mini_window)->height) = 1;
     }
 
-  /* Choose a buffer for the screen's root window.  */
+  /* Choose a buffer for the frame's root window.  */
   {
     Lisp_Object buf;
 
@@ -167,82 +167,82 @@ make_screen (mini_p)
                            : Fcar (Vminibuffer_list)));
     }
 
-  s->root_window = root_window;
-  s->selected_window = root_window;
+  f->root_window = root_window;
+  f->selected_window = root_window;
   /* Make sure this window seems more recently used than
      a newly-created, never-selected window.  */
-  XFASTINT (XWINDOW (s->selected_window)->use_time) = ++window_select_count;
+  XFASTINT (XWINDOW (f->selected_window)->use_time) = ++window_select_count;
 
-  Vscreen_list = Fcons (screen, Vscreen_list);
+  Vframe_list = Fcons (frame, Vframe_list);
 
-  return s;
+  return f;
 }
 
-/* Make a screen using a separate minibuffer window on another screen.
+/* Make a frame using a separate minibuffer window on another frame.
    MINI_WINDOW is the minibuffer window to use.  nil means use the
    default (the global minibuffer).  */
 
-struct screen *
-make_screen_without_minibuffer (mini_window)
+struct frame *
+make_frame_without_minibuffer (mini_window)
      register Lisp_Object mini_window;
 {
-  register struct screen *s;
+  register struct frame *f;
 
   /* Choose the minibuffer window to use.  */
   if (NILP (mini_window))
     {
-      if (XTYPE (Vdefault_minibuffer_screen) != Lisp_Screen)
-        error ("default-minibuffer-screen must be set when creating minibufferless screens");
-      if (! SCREEN_LIVE_P (XSCREEN (Vdefault_minibuffer_screen)))
-        error ("default-minibuffer-screen must be a live screen");
-      mini_window = XSCREEN (Vdefault_minibuffer_screen)->minibuffer_window;
+      if (XTYPE (Vdefault_minibuffer_frame) != Lisp_Frame)
+        error ("default-minibuffer-frame must be set when creating minibufferless frames");
+      if (! FRAME_LIVE_P (XFRAME (Vdefault_minibuffer_frame)))
+        error ("default-minibuffer-frame must be a live frame");
+      mini_window = XFRAME (Vdefault_minibuffer_frame)->minibuffer_window;
     }
   else
     {
       CHECK_WINDOW (mini_window, 0);
     }
 
-  /* Make a screen containing just a root window.  */
-  s = make_screen (0);
+  /* Make a frame containing just a root window.  */
+  f = make_frame (0);
 
   /* Install the chosen minibuffer window, with proper buffer.  */
-  s->minibuffer_window = mini_window;
+  f->minibuffer_window = mini_window;
   Fset_window_buffer (mini_window,
                       (NILP (Vminibuffer_list)
                        ? get_minibuffer (0)
                        : Fcar (Vminibuffer_list)));
-  return s;
+  return f;
 }
 
-/* Make a screen containing only a minibuffer window.  */
+/* Make a frame containing only a minibuffer window.  */
 
-struct screen *
-make_minibuffer_screen ()
+struct frame *
+make_minibuffer_frame ()
 {
-  /* First make a screen containing just a root window, no minibuffer.  */
+  /* First make a frame containing just a root window, no minibuffer.  */
 
-  register struct screen *s = make_screen (0);
+  register struct frame *f = make_frame (0);
   register Lisp_Object mini_window;
-  register Lisp_Object screen;
+  register Lisp_Object frame;
 
-  XSET (screen, Lisp_Screen, s);
+  XSET (frame, Lisp_Frame, f);
 
   /* ??? Perhaps leave it to the user program to set auto_raise.  */
-  s->auto_raise = 1;
-  s->auto_lower = 0;
-  s->no_split = 1;
-  s->wants_modeline = 0;
-  s->has_minibuffer = 1;
+  f->auto_raise = 1;
+  f->auto_lower = 0;
+  f->no_split = 1;
+  f->wants_modeline = 0;
+  f->has_minibuffer = 1;
 
   /* Now label the root window as also being the minibuffer.
      Avoid infinite looping on the window chain by marking next pointer
      as nil. */
 
-  mini_window = s->minibuffer_window = s->root_window;
+  mini_window = f->minibuffer_window = f->root_window;
   XWINDOW (mini_window)->mini_p = Qt;
   XWINDOW (mini_window)->next = Qnil;
   XWINDOW (mini_window)->prev = mini_window;
-  XWINDOW (mini_window)->screen = screen;
+  XWINDOW (mini_window)->frame = frame;
 
   /* Put the proper buffer in that window.  */
 
@@ -250,347 +250,347 @@ make_minibuffer_screen ()
                       (NILP (Vminibuffer_list)
                        ? get_minibuffer (0)
                        : Fcar (Vminibuffer_list)));
-  return s;
+  return f;
 }
 
-/* Construct a screen that refers to the terminal (stdin and stdout).  */
+/* Construct a frame that refers to the terminal (stdin and stdout).  */
 
-struct screen *
-make_terminal_screen ()
+struct frame *
+make_terminal_frame ()
 {
-  register struct screen *s;
-
-  Vscreen_list = Qnil;
-  s = make_screen (1);
-  s->name = build_string ("terminal");
-  s->visible = 1;
-  s->display.nothing = 1;   /* Nonzero means screen isn't deleted.  */
-  XSET (Vterminal_screen, Lisp_Screen, s);
-  return s;
+  register struct frame *f;
+
+  Vframe_list = Qnil;
+  f = make_frame (1);
+  f->name = build_string ("terminal");
+  f->visible = 1;
+  f->display.nothing = 1;   /* Nonzero means frame isn't deleted.  */
+  XSET (Vterminal_frame, Lisp_Frame, f);
+  return f;
 }
 
-DEFUN ("select-screen", Fselect_screen, Sselect_screen, 1, 2, 0,
-  "Select the screen S.  S's selected window becomes \"the\"\n\
+DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 2, 0,
+  "Select the frame FRAME.  FRAMES's selected window becomes \"the\"\n\
 selected window.  If the optional parameter NO-ENTER is non-nil, don't\n\
-focus on that screen.")
-  (screen, no_enter)
-     Lisp_Object screen, no_enter;
+focus on that frame.")
+  (frame, no_enter)
+     Lisp_Object frame, no_enter;
 {
-  CHECK_LIVE_SCREEN (screen, 0);
+  CHECK_LIVE_FRAME (frame, 0);
 
-  if (selected_screen == XSCREEN (screen))
-    return screen;
+  if (selected_frame == XFRAME (frame))
+    return frame;
 
-  selected_screen = XSCREEN (screen);
-  if (! SCREEN_MINIBUF_ONLY_P (selected_screen))
-    last_nonminibuf_screen = selected_screen;
+  selected_frame = XFRAME (frame);
+  if (! FRAME_MINIBUF_ONLY_P (selected_frame))
+    last_nonminibuf_frame = selected_frame;
 
-  Fselect_window (XSCREEN (screen)->selected_window);
+  Fselect_window (XFRAME (frame)->selected_window);
 
 #ifdef HAVE_X_WINDOWS
-#ifdef MULTI_SCREEN
-  if (SCREEN_IS_X (XSCREEN (screen))
+#ifdef MULTI_FRAME
+  if (FRAME_IS_X (XFRAME (frame))
       && NILP (no_enter))
     {
-      Ffocus_screen (screen);
+      Ffocus_frame (frame);
     }
 #endif
 #endif
-  choose_minibuf_screen ();
+  choose_minibuf_frame ();
 
-  return screen;
+  return frame;
 }
 
-DEFUN ("selected-screen", Fselected_screen, Sselected_screen, 0, 0, 0,
-  "Return the screen that is now selected.")
+DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
+  "Return the frame that is now selected.")
   ()
 {
   Lisp_Object tem;
-  XSET (tem, Lisp_Screen, selected_screen);
+  XSET (tem, Lisp_Frame, selected_frame);
   return tem;
 }
 
-DEFUN ("window-screen", Fwindow_screen, Swindow_screen, 1, 1, 0,
-  "Return the screen object that window WINDOW is on.")
+DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
+  "Return the frame object that window WINDOW is on.")
   (window)
      Lisp_Object window;
 {
   CHECK_WINDOW (window, 0);
-  return XWINDOW (window)->screen;
+  return XWINDOW (window)->frame;
 }
 
-DEFUN ("screen-root-window", Fscreen_root_window, Sscreen_root_window, 0, 1, 0,
-       "Returns the root-window of SCREEN.")
-  (screen)
-     Lisp_Object screen;
+DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
+       "Returns the root-window of FRAME.")
+  (frame)
+     Lisp_Object frame;
 {
-  if (NILP (screen))
-    XSET (screen, Lisp_Screen, selected_screen);
+  if (NILP (frame))
+    XSET (frame, Lisp_Frame, selected_frame);
   else
-    CHECK_LIVE_SCREEN (screen, 0);
+    CHECK_LIVE_FRAME (frame, 0);
 
-  return XSCREEN (screen)->root_window;
+  return XFRAME (frame)->root_window;
 }
 
-DEFUN ("screen-selected-window", Fscreen_selected_window,
-       Sscreen_selected_window, 0, 1, 0,
-  "Return the selected window of screen object SCREEN.")
-  (screen)
-     Lisp_Object screen;
+DEFUN ("frame-selected-window", Fframe_selected_window,
+       Sframe_selected_window, 0, 1, 0,
+  "Return the selected window of frame object FRAME.")
+  (frame)
+     Lisp_Object frame;
 {
-  if (NILP (screen))
-    XSET (screen, Lisp_Screen, selected_screen);
+  if (NILP (frame))
+    XSET (frame, Lisp_Frame, selected_frame);
   else
-    CHECK_LIVE_SCREEN (screen, 0);
+    CHECK_LIVE_FRAME (frame, 0);
 
-  return XSCREEN (screen)->selected_window;
+  return XFRAME (frame)->selected_window;
 }
 
-DEFUN ("screen-list", Fscreen_list, Sscreen_list,
+DEFUN ("frame-list", Fframe_list, Sframe_list,
        0, 0, 0,
-       "Return a list of all screens.")
+       "Return a list of all frames.")
   ()
 {
-  return Fcopy_sequence (Vscreen_list);
+  return Fcopy_sequence (Vframe_list);
 }
 
-#ifdef MULTI_SCREEN
+#ifdef MULTI_FRAME
 
-/* Return the next screen in the screen list after SCREEN.
-   If MINIBUF is non-nil, include all screens.
-   If MINIBUF is nil, exclude minibuffer-only screens.
-   If MINIBUF is a window, include only screens using that window for
+/* Return the next frame in the frame list after FRAME.
+   If MINIBUF is non-nil, include all frames.
+   If MINIBUF is nil, exclude minibuffer-only frames.
+   If MINIBUF is a window, include only frames using that window for
    their minibuffer.  */
 Lisp_Object
-next_screen (screen, minibuf)
-     Lisp_Object screen;
+next_frame (frame, minibuf)
+     Lisp_Object frame;
      Lisp_Object minibuf;
 {
   Lisp_Object tail;
   int passed = 0;
 
-  /* There must always be at least one screen in Vscreen_list.  */
-  if (! CONSP (Vscreen_list))
+  /* There must always be at least one frame in Vframe_list.  */
+  if (! CONSP (Vframe_list))
     abort ();
 
   while (1)
-    for (tail = Vscreen_list; CONSP (tail); tail = XCONS (tail)->cdr)
+    for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
       {
         if (passed)
           {
-            Lisp_Object s = XCONS (tail)->car;
+            Lisp_Object f = XCONS (tail)->car;
 
-            /* Decide whether this screen is eligible to be returned,
+            /* Decide whether this frame is eligible to be returned,
                according to minibuf.  */
-            if ((NILP (minibuf) && ! SCREEN_MINIBUF_ONLY_P (XSCREEN (s)))
+            if ((NILP (minibuf) && ! FRAME_MINIBUF_ONLY_P (XFRAME (f)))
                 || XTYPE (minibuf) != Lisp_Window
-                || EQ (SCREEN_MINIBUF_WINDOW (XSCREEN (s)), minibuf)
-                || EQ (s, screen))
-              return s;
+                || EQ (FRAME_MINIBUF_WINDOW (XFRAME (f)), minibuf)
+                || EQ (f, frame))
+              return f;
           }
 
-        if (EQ (screen, XCONS (tail)->car))
+        if (EQ (frame, XCONS (tail)->car))
           passed++;
       }
 }
 
-/* Return the previous screen in the screen list before SCREEN.
-   If MINIBUF is non-nil, include all screens.
-   If MINIBUF is nil, exclude minibuffer-only screens.
-   If MINIBUF is a window, include only screens using that window for
+/* Return the previous frame in the frame list before FRAME.
+   If MINIBUF is non-nil, include all frames.
+   If MINIBUF is nil, exclude minibuffer-only frames.
+   If MINIBUF is a window, include only frames using that window for
    their minibuffer.  */
 Lisp_Object
-prev_screen (screen, minibuf)
-     Lisp_Object screen;
+prev_frame (frame, minibuf)
+     Lisp_Object frame;
      Lisp_Object minibuf;
 {
   Lisp_Object tail;
   Lisp_Object prev;
 
-  /* There must always be at least one screen in Vscreen_list.  */
-  if (! CONSP (Vscreen_list))
+  /* There must always be at least one frame in Vframe_list.  */
+  if (! CONSP (Vframe_list))
     abort ();
 
   prev = Qnil;
   while (1)
     {
-      for (tail = Vscreen_list; CONSP (tail); tail = XCONS (tail)->cdr)
+      for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
         {
           Lisp_Object scr = XCONS (tail)->car;
 
-          if (XTYPE (scr) != Lisp_Screen)
+          if (XTYPE (scr) != Lisp_Frame)
             abort ();
 
-          if (EQ (screen, scr) && !NILP (prev))
+          if (EQ (frame, scr) && !NILP (prev))
             return prev;
 
-          /* Decide whether this screen is eligible to be returned,
+          /* Decide whether this frame is eligible to be returned,
              according to minibuf.  */
-          if ((NILP (minibuf) && ! SCREEN_MINIBUF_ONLY_P (XSCREEN (scr)))
+          if ((NILP (minibuf) && ! FRAME_MINIBUF_ONLY_P (XFRAME (scr)))
               || XTYPE (minibuf) != Lisp_Window
-              || EQ (SCREEN_MINIBUF_WINDOW (XSCREEN (scr)), minibuf))
+              || EQ (FRAME_MINIBUF_WINDOW (XFRAME (scr)), minibuf))
             prev = scr;
         }
 
       if (NILP (prev))
-        /* We went through the whole screen list without finding a single
-           acceptable screen.  Return the original screen.  */
-        prev = screen;
+        /* We went through the whole frame list without finding a single
+           acceptable frame.  Return the original frame.  */
+        prev = frame;
     }
           
 }
 
-DEFUN ("next-screen", Fnext_screen, Snext_screen, 0, 2, 0,
-  "Return the next screen in the screen list after SCREEN.\n\
-If optional argument MINIBUF is non-nil, include all screens.  If\n\
-MINIBUF is nil or omitted, exclude minibuffer-only screens.  If\n\
-MINIBUF is a window, include only screens using that window for their\n\
+DEFUN ("next-frame", Fnext_frame, Snext_frame, 0, 2, 0,
+  "Return the next frame in the frame list after FRAME.\n\
+If optional argument MINIBUF is non-nil, include all frames.  If\n\
+MINIBUF is nil or omitted, exclude minibuffer-only frames.  If\n\
+MINIBUF is a window, include only frames using that window for their\n\
 minibuffer.")
-  (screen, miniscreen)
-Lisp_Object screen, miniscreen;
+  (frame, miniframe)
+Lisp_Object frame, miniframe;
 {
   Lisp_Object tail;
 
-  if (NILP (screen))
-    XSET (screen, Lisp_Screen, selected_screen);
+  if (NILP (frame))
+    XSET (frame, Lisp_Frame, selected_frame);
   else
-    CHECK_LIVE_SCREEN (screen, 0);
+    CHECK_LIVE_FRAME (frame, 0);
 
-  return next_screen (screen, miniscreen);
+  return next_frame (frame, miniframe);
 }
-#endif /* MULTI_SCREEN */
+#endif /* MULTI_FRAME */
 
-DEFUN ("delete-screen", Fdelete_screen, Sdelete_screen, 0, 1, "",
-  "Delete SCREEN, permanently eliminating it from use.\n\
-If omitted, SCREEN defaults to the selected screen.\n\
-A screen may not be deleted if its minibuffer is used by other screens.")
-  (screen)
-     Lisp_Object screen;
+DEFUN ("delete-frame", Fdelete_frame, Sdelete_frame, 0, 1, "",
+  "Delete FRAME, permanently eliminating it from use.\n\
+If omitted, FRAME defaults to the selected frame.\n\
+A frame may not be deleted if its minibuffer is used by other frames.")
+  (frame)
+     Lisp_Object frame;
 {
-  struct screen *s;
+  struct frame *f;
   union display displ;
 
-  if (EQ (screen, Qnil))
+  if (EQ (frame, Qnil))
     {
-      s = selected_screen;
-      XSET (screen, Lisp_Screen, s);
+      f = selected_frame;
+      XSET (frame, Lisp_Frame, f);
     }
   else
     {
-      CHECK_SCREEN (screen, 0);
-      s = XSCREEN (screen);
+      CHECK_FRAME (frame, 0);
+      f = XFRAME (frame);
     }
 
-  if (! SCREEN_LIVE_P (s))
+  if (! FRAME_LIVE_P (f))
     return;
 
-  /* Are there any other screens besides this one?  */
-  if (s == selected_screen && EQ (next_screen (screen, Qt), screen))
-    error ("Attempt to delete the only screen");
+  /* Are there any other frames besides this one?  */
+  if (f == selected_frame && EQ (next_frame (frame, Qt), frame))
+    error ("Attempt to delete the only frame");
 
-  /* Does this screen have a minibuffer, and is it the surrogate
-     minibuffer for any other screen?  */
-  if (SCREEN_HAS_MINIBUF (XSCREEN (screen)))
+  /* Does this frame have a minibuffer, and is it the surrogate
+     minibuffer for any other frame?  */
+  if (FRAME_HAS_MINIBUF (XFRAME (frame)))
     {
-      Lisp_Object screens;
+      Lisp_Object frames;
 
-      for (screens = Vscreen_list;
-           CONSP (screens);
-           screens = XCONS (screens)->cdr)
+      for (frames = Vframe_list;
+           CONSP (frames);
+           frames = XCONS (frames)->cdr)
         {
-          Lisp_Object this = XCONS (screens)->car;
+          Lisp_Object this = XCONS (frames)->car;
 
-          if (! EQ (this, screen)
-              && EQ (screen,
-                     (WINDOW_SCREEN
+          if (! EQ (this, frame)
+              && EQ (frame,
+                     (WINDOW_FRAME
                       (XWINDOW
-                       (SCREEN_MINIBUF_WINDOW
-                        (XSCREEN (this)))))))
-            error ("Attempt to delete a surrogate minibuffer screen");
+                       (FRAME_MINIBUF_WINDOW
+                        (XFRAME (this)))))))
+            error ("Attempt to delete a surrogate minibuffer frame");
         }
     }
 
-  /* Don't let the screen remain selected.  */
-  if (s == selected_screen)
-    Fselect_screen (next_screen (screen, Qt));
+  /* Don't let the frame remain selected.  */
+  if (f == selected_frame)
+    Fselect_frame (next_frame (frame, Qt));
 
-  /* Don't allow minibuf_window to remain on a deleted screen.  */
-  if (EQ (s->minibuffer_window, minibuf_window))
+  /* Don't allow minibuf_window to remain on a deleted frame.  */
+  if (EQ (f->minibuffer_window, minibuf_window))
     {
-      Fset_window_buffer (selected_screen->minibuffer_window,
+      Fset_window_buffer (selected_frame->minibuffer_window,
                           XWINDOW (minibuf_window)->buffer);
-      minibuf_window = selected_screen->minibuffer_window;
+      minibuf_window = selected_frame->minibuffer_window;
     }
 
-  Vscreen_list = Fdelq (screen, Vscreen_list);
-  s->visible = 0;
-  displ = s->display;
-  s->display.nothing = 0;
+  Vframe_list = Fdelq (frame, Vframe_list);
+  f->visible = 0;
+  displ = f->display;
+  f->display.nothing = 0;
 
 #ifdef HAVE_X_WINDOWS
-  if (SCREEN_IS_X (s))
-    x_destroy_window (s, displ);
+  if (FRAME_IS_X (f))
+    x_destroy_window (f, displ);
 #endif
 
-  /* If we've deleted the last_nonminibuf_screen, then try to find
+  /* If we've deleted the last_nonminibuf_frame, then try to find
      another one.  */
-  if (s == last_nonminibuf_screen)
+  if (f == last_nonminibuf_frame)
     {
-      Lisp_Object screens;
+      Lisp_Object frames;
 
-      last_nonminibuf_screen = 0;
+      last_nonminibuf_frame = 0;
 
-      for (screens = Vscreen_list;
-           CONSP (screens);
-           screens = XCONS (screens)->cdr)
+      for (frames = Vframe_list;
+           CONSP (frames);
+           frames = XCONS (frames)->cdr)
         {
-          s = XSCREEN (XCONS (screens)->car);
-          if (!SCREEN_MINIBUF_ONLY_P (s))
+          f = XFRAME (XCONS (frames)->car);
+          if (!FRAME_MINIBUF_ONLY_P (f))
             {
-              last_nonminibuf_screen = s;
+              last_nonminibuf_frame = f;
               break;
             }
         }
     }
 
-  /* If we've deleted Vdefault_minibuffer_screen, try to find another
-     one.  Prefer minibuffer-only screens, but also notice screens
+  /* If we've deleted Vdefault_minibuffer_frame, try to find another
+     one.  Prefer minibuffer-only frames, but also notice frames
      with other windows.  */
-  if (EQ (screen, Vdefault_minibuffer_screen))
+  if (EQ (frame, Vdefault_minibuffer_frame))
     {
-      Lisp_Object screens;
+      Lisp_Object frames;
 
-      /* The last screen we saw with a minibuffer, minibuffer-only or not.  */
-      Lisp_Object screen_with_minibuf = Qnil;
+      /* The last frame we saw with a minibuffer, minibuffer-only or not.  */
+      Lisp_Object frame_with_minibuf = Qnil;
 
-      for (screens = Vscreen_list;
-           CONSP (screens);
-           screens = XCONS (screens)->cdr)
+      for (frames = Vframe_list;
+           CONSP (frames);
+           frames = XCONS (frames)->cdr)
         {
-          Lisp_Object this = XCONS (screens)->car;
+          Lisp_Object this = XCONS (frames)->car;
 
-          if (XTYPE (this) != Lisp_Screen)
+          if (XTYPE (this) != Lisp_Frame)
             abort ();
-          s = XSCREEN (this);
+          f = XFRAME (this);
 
-          if (SCREEN_HAS_MINIBUF (s))
+          if (FRAME_HAS_MINIBUF (f))
             {
-              screen_with_minibuf = this;
-              if (SCREEN_MINIBUF_ONLY_P (s))
+              frame_with_minibuf = this;
+              if (FRAME_MINIBUF_ONLY_P (f))
                 break;
             }
         }
 
-      /* We know that there must be some screen with a minibuffer out
-         there.  If this were not true, all of the screens present
+      /* We know that there must be some frame with a minibuffer out
+         there.  If this were not true, all of the frames present
          would have to be minibufferless, which implies that at some
-         point their minibuffer screens must have been deleted, but
+         point their minibuffer frames must have been deleted, but
          that is prohibited at the top; you can't delete surrogate
-         minibuffer screens.  */
-      if (NILP (screen_with_minibuf))
+         minibuffer frames.  */
+      if (NILP (frame_with_minibuf))
         abort ();
 
-      Vdefault_minibuffer_screen = screen_with_minibuf;
+      Vdefault_minibuffer_frame = frame_with_minibuf;
     }
 
   return Qnil;
@@ -599,41 +599,41 @@ A screen may not be deleted if its minibuffer is used by other screens.")
 /* Return mouse position in character cell units.  */
 
 DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 0, 0,
-  "Return a list (SCREEN X . Y) giving the current mouse screen and position.\n\
+  "Return a list (FRAME X . Y) giving the current mouse frame and position.\n\
 If Emacs is running on a mouseless terminal or hasn't been programmed\n\
-to read the mouse position, it returns the selected screen for SCREEN\n\
+to read the mouse position, it returns the selected frame for FRAME\n\
 and nil for X and Y.")
   ()
 {
   Lisp_Object x, y, dummy;
-  SCREEN_PTR s;
+  FRAME_PTR f;
 
   if (mouse_position_hook)
-    (*mouse_position_hook) (&s, &x, &y, &dummy);
+    (*mouse_position_hook) (&f, &x, &y, &dummy);
   else
     {
-      s = selected_screen;
+      f = selected_frame;
       x = y = Qnil;
     }
 
-  XSET (dummy, Lisp_Screen, s);
+  XSET (dummy, Lisp_Frame, f);
   return Fcons (dummy, Fcons (make_number (x), make_number (y)));
 }
 
 DEFUN ("set-mouse-position", Fset_mouse_position, Sset_mouse_position, 3, 3, 0,
-  "Move the mouse pointer to the center of cell (X,Y) in SCREEN.\n\
-WARNING:  If you use this under X, you should do `unfocus-screen' afterwards.")
-  (screen, x, y)
-     Lisp_Object screen, x, y;
+  "Move the mouse pointer to the center of cell (X,Y) in FRAME.\n\
+WARNING:  If you use this under X, you should do `unfocus-frame' afterwards.")
+  (frame, x, y)
+     Lisp_Object frame, x, y;
 {
-  CHECK_LIVE_SCREEN (screen, 0);
+  CHECK_LIVE_FRAME (frame, 0);
   CHECK_NUMBER (x, 2);
   CHECK_NUMBER (y, 1);
 
 #ifdef HAVE_X_WINDOWS
-  if (SCREEN_IS_X (XSCREEN (screen)))
+  if (FRAME_IS_X (XFRAME (frame)))
     /* Warping the mouse will cause  enternotify and focus events. */
-    x_set_mouse_position (XSCREEN (screen), x, y);
+    x_set_mouse_position (XFRAME (frame), x, y);
 #endif
 
   return Qnil;
@@ -643,20 +643,20 @@ WARNING:  If you use this under X, you should do `unfocus-screen' afterwards.")
 /* ??? Can this be replaced with a Lisp function?
    It is used in minibuf.c.  Can we get rid of that?
    Yes.  All uses in minibuf.c are gone, and parallels to these
-   functions have been defined in screen.el.  */
+   functions have been defined in frame.el.  */
 
-DEFUN ("screen-configuration", Fscreen_configuration, Sscreen_configuration,
+DEFUN ("frame-configuration", Fframe_configuration, Sframe_configuration,
        0, 0, 0,
-  "Return object describing current screen configuration.\n\
-The screen configuration is the current mouse position and selected screen.\n\
-This object can be given to `restore-screen-configuration'\n\
-to restore this screen configuration.")
+  "Return object describing current frame configuration.\n\
+The frame configuration is the current mouse position and selected frame.\n\
+This object can be given to `restore-frame-configuration'\n\
+to restore this frame configuration.")
   ()
 {
   Lisp_Object c, time;
   
   c = Fmake_vector (make_number(4), Qnil);
-  XVECTOR (c)->contents[0] = Fselected_screen();
+  XVECTOR (c)->contents[0] = Fselected_frame();
   if (mouse_position_hook)
     (*mouse_position_hook) (&XVECTOR (c)->contents[1]
                             &XVECTOR (c)->contents[2],
@@ -665,174 +665,174 @@ to restore this screen configuration.")
   return c;
 }
 
-DEFUN ("restore-screen-configuration", Frestore_screen_configuration,
-       Srestore_screen_configuration,
+DEFUN ("restore-frame-configuration", Frestore_frame_configuration,
+       Srestore_frame_configuration,
        1, 1, 0,
-  "Restores screen configuration CONFIGURATION.")
+  "Restores frame configuration CONFIGURATION.")
   (config)
   Lisp_Object config;
 {
-  Lisp_Object x_pos, y_pos, screen;
+  Lisp_Object x_pos, y_pos, frame;
 
   CHECK_VECTOR (config, 0);
   if (XVECTOR (config)->size != 3)
     {
-      error ("Wrong size vector passed to restore-screen-configuration");
+      error ("Wrong size vector passed to restore-frame-configuration");
     }
-  screen = XVECTOR (config)->contents[0];
-  CHECK_LIVE_SCREEN (screen, 0);
+  frame = XVECTOR (config)->contents[0];
+  CHECK_LIVE_FRAME (frame, 0);
 
-  Fselect_screen (screen, Qnil);
+  Fselect_frame (frame, Qnil);
 
 #if 0
-  /* This seems to interfere with the screen selection mechanism. jla */
+  /* This seems to interfere with the frame selection mechanism. jla */
   x_pos = XVECTOR (config)->contents[2];
   y_pos = XVECTOR (config)->contents[3];
-  set_mouse_position (screen, XINT (x_pos), XINT (y_pos));
+  set_mouse_position (frame, XINT (x_pos), XINT (y_pos));
 #endif
 
-  return screen;
+  return frame;
 }    
 #endif
 
-DEFUN ("make-screen-visible", Fmake_screen_visible, Smake_screen_visible,
+DEFUN ("make-frame-visible", Fmake_frame_visible, Smake_frame_visible,
        1, 1, 0,
-  "Make the screen SCREEN visible (assuming it is an X-window).\n\
-Also raises the screen so that nothing obscures it.")
-  (screen)
-     Lisp_Object screen;
+  "Make the frame FRAME visible (assuming it is an X-window).\n\
+Also raises the frame so that nothing obscures it.")
+  (frame)
+     Lisp_Object frame;
 {
-  CHECK_LIVE_SCREEN (screen, 0);
+  CHECK_LIVE_FRAME (frame, 0);
 
-  if (SCREEN_IS_X (XSCREEN (screen)))
-    x_make_screen_visible (XSCREEN (screen));
+  if (FRAME_IS_X (XFRAME (frame)))
+    x_make_frame_visible (XFRAME (frame));
 
-  return screen;
+  return frame;
 }
 
-DEFUN ("make-screen-invisible", Fmake_screen_invisible, Smake_screen_invisible,
+DEFUN ("make-frame-invisible", Fmake_frame_invisible, Smake_frame_invisible,
        1, 1, 0,
-  "Make the screen SCREEN invisible (assuming it is an X-window).")
-  (screen)
-     Lisp_Object screen;
+  "Make the frame FRAME invisible (assuming it is an X-window).")
+  (frame)
+     Lisp_Object frame;
 {
-  CHECK_LIVE_SCREEN (screen, 0);
+  CHECK_LIVE_FRAME (frame, 0);
 
-  if (SCREEN_IS_X (XSCREEN (screen)))
-    x_make_screen_invisible (XSCREEN (screen));
+  if (FRAME_IS_X (XFRAME (frame)))
+    x_make_frame_invisible (XFRAME (frame));
 
   return Qnil;
 }
 
-DEFUN ("iconify-screen", Ficonify_screen, Siconify_screen,
+DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
        1, 1, 0,
-  "Make the screen SCREEN into an icon.")
-  (screen)
-     Lisp_Object screen;
+  "Make the frame FRAME into an icon.")
+  (frame)
+     Lisp_Object frame;
 {
-  CHECK_LIVE_SCREEN (screen, 0);
+  CHECK_LIVE_FRAME (frame, 0);
 
-  if (SCREEN_IS_X (XSCREEN (screen)))
-      x_iconify_screen (XSCREEN (screen));
+  if (FRAME_IS_X (XFRAME (frame)))
+      x_iconify_frame (XFRAME (frame));
 
   return Qnil;
 }
 
-DEFUN ("screen-visible-p", Fscreen_visible_p, Sscreen_visible_p,
+DEFUN ("frame-visible-p", Fframe_visible_p, Sframe_visible_p,
        1, 1, 0,
-       "Return t if SCREEN is now \"visible\" (actually in use for display).\n\
-A screen that is not \"visible\" is not updated and, if it works through\n\
+       "Return t if FRAME is now \"visible\" (actually in use for display).\n\
+A frame that is not \"visible\" is not updated and, if it works through\n\
 a window system, it may not show at all.\n\
 Return the symbol `icon' if window is visible only as an icon.")
-  (screen)
-     Lisp_Object screen;
+  (frame)
+     Lisp_Object frame;
 {
-  CHECK_LIVE_SCREEN (screen, 0);
+  CHECK_LIVE_FRAME (frame, 0);
 
-  if (XSCREEN (screen)->visible)
+  if (XFRAME (frame)->visible)
     return Qt;
-  if (XSCREEN (screen)->iconified)
+  if (XFRAME (frame)->iconified)
     return intern ("icon");
   return Qnil;
 }
 
-DEFUN ("visible-screen-list", Fvisible_screen_list, Svisible_screen_list,
+DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
        0, 0, 0,
-       "Return a list of all screens now \"visible\" (being updated).")
+       "Return a list of all frames now \"visible\" (being updated).")
   ()
 {
-  Lisp_Object tail, screen;
-  struct screen *s;
+  Lisp_Object tail, frame;
+  struct frame *f;
   Lisp_Object value;
 
   value = Qnil;
-  for (tail = Vscreen_list; CONSP (tail); tail = XCONS (tail)->cdr)
+  for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
     {
-      screen = XCONS (tail)->car;
-      if (XTYPE (screen) != Lisp_Screen)
+      frame = XCONS (tail)->car;
+      if (XTYPE (frame) != Lisp_Frame)
         continue;
-      s = XSCREEN (screen);
-      if (s->visible)
-        value = Fcons (screen, value);
+      f = XFRAME (frame);
+      if (f->visible)
+        value = Fcons (frame, value);
     }
   return value;
 }
 
 
 
-DEFUN ("redirect-screen-focus", Fredirect_screen_focus, Sredirect_screen_focus,
+DEFUN ("redirect-frame-focus", Fredirect_frame_focus, Sredirect_frame_focus,
        1, 2, 0,
-  "Arrange for keystrokes typed at SCREEN to be sent to FOCUS-SCREEN.\n\
-This means that, after reading a keystroke typed at SCREEN,\n\
-`last-event-screen' will be FOCUS-SCREEN.\n\
+  "Arrange for keystrokes typed at FRAME to be sent to FOCUS-FRAME.\n\
+This means that, after reading a keystroke typed at FRAME,\n\
+`last-event-frame' will be FOCUS-FRAME.\n\
 \n\
-If FOCUS-SCREEN is omitted or eq to SCREEN, any existing redirection is\n\
-cancelled, and the screen again receives its own keystrokes.\n\
+If FOCUS-FRAME is omitted or eq to FRAME, any existing redirection is\n\
+cancelled, and the frame again receives its own keystrokes.\n\
 \n\
-The redirection lasts until the next call to `redirect-screen-focus'\n\
-or `select-screen'.\n\
+The redirection lasts until the next call to `redirect-frame-focus'\n\
+or `select-frame'.\n\
 \n\
 This is useful for temporarily redirecting keystrokes to the minibuffer\n\
-window when a screen doesn't have its own minibuffer.")
-  (screen, focus_screen)
-    Lisp_Object screen, focus_screen;
+window when a frame doesn't have its own minibuffer.")
+  (frame, focus_frame)
+    Lisp_Object frame, focus_frame;
 {
-  CHECK_LIVE_SCREEN (screen, 0);
+  CHECK_LIVE_FRAME (frame, 0);
 
-  if (NILP (focus_screen))
-    focus_screen = screen;
+  if (NILP (focus_frame))
+    focus_frame = frame;
   else
-    CHECK_LIVE_SCREEN (focus_screen, 1);
+    CHECK_LIVE_FRAME (focus_frame, 1);
 
-  XSCREEN (screen)->focus_screen = focus_screen;
+  XFRAME (frame)->focus_frame = focus_frame;
 
-  if (screen_rehighlight_hook)
-    (*screen_rehighlight_hook) ();
+  if (frame_rehighlight_hook)
+    (*frame_rehighlight_hook) ();
   
   return Qnil;
 }
 
 
-DEFUN ("screen-focus", Fscreen_focus, Sscreen_focus, 1, 1, 0,
-  "Return the screen to which SCREEN's keystrokes are currently being sent.\n\
-See `redirect-screen-focus'.")
-  (screen)
-    Lisp_Object screen;
+DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 1, 1, 0,
+  "Return the frame to which FRAME's keystrokes are currently being sent.\n\
+See `redirect-frame-focus'.")
+  (frame)
+    Lisp_Object frame;
 {
-  CHECK_LIVE_SCREEN (screen, 0);
-  return SCREEN_FOCUS_SCREEN (XSCREEN (screen));
+  CHECK_LIVE_FRAME (frame, 0);
+  return FRAME_FOCUS_FRAME (XFRAME (frame));
 }
 
 
 
 Lisp_Object
-get_screen_param (screen, prop)
-     register struct screen *screen;
+get_frame_param (frame, prop)
+     register struct frame *frame;
      Lisp_Object prop;
 {
   register Lisp_Object tem;
 
-  tem = Fassq (prop, screen->param_alist);
+  tem = Fassq (prop, frame->param_alist);
   if (EQ (tem, Qnil))
     return tem;
   return Fcdr (tem);
@@ -855,15 +855,15 @@ store_in_alist (alistptr, propname, val)
 }
 
 void
-store_screen_param (s, prop, val)
-     struct screen *s;
+store_frame_param (f, prop, val)
+     struct frame *f;
      Lisp_Object prop, val;
 {
   register Lisp_Object tem;
 
-  tem = Fassq (prop, s->param_alist);
+  tem = Fassq (prop, f->param_alist);
   if (EQ (tem, Qnil))
-    s->param_alist = Fcons (Fcons (prop, val), s->param_alist);
+    f->param_alist = Fcons (Fcons (prop, val), f->param_alist);
   else
     Fsetcdr (tem, val);
 
@@ -873,214 +873,214 @@ store_screen_param (s, prop, val)
       if (! MINI_WINDOW_P (XWINDOW (val)))
         error ("Surrogate minibuffer windows must be minibuffer windows.");
 
-      if (SCREEN_HAS_MINIBUF (s) || SCREEN_MINIBUF_ONLY_P (s))
-        error ("Can't change the surrogate minibuffer of a screen with its own minibuffer.");
+      if (FRAME_HAS_MINIBUF (f) || FRAME_MINIBUF_ONLY_P (f))
+        error ("Can't change the surrogate minibuffer of a frame with its own minibuffer.");
 
       /* Install the chosen minibuffer window, with proper buffer.  */
-      s->minibuffer_window = val;
+      f->minibuffer_window = val;
     }
 }
 
-DEFUN ("screen-parameters", Fscreen_parameters, Sscreen_parameters, 0, 1, 0,
-  "Return the parameters-alist of screen SCREEN.\n\
+DEFUN ("frame-parameters", Fframe_parameters, Sframe_parameters, 0, 1, 0,
+  "Return the parameters-alist of frame FRAME.\n\
 It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.\n\
-The meaningful PARMs depend on the kind of screen.")
-  (screen)
-     Lisp_Object screen;
+The meaningful PARMs depend on the kind of frame.")
+  (frame)
+     Lisp_Object frame;
 {
   Lisp_Object alist;
-  struct screen *s;
+  struct frame *f;
 
-  if (EQ (screen, Qnil))
-    s = selected_screen;
+  if (EQ (frame, Qnil))
+    f = selected_frame;
   else
     {
-      CHECK_SCREEN (screen, 0);
-      s = XSCREEN (screen);
+      CHECK_FRAME (frame, 0);
+      f = XFRAME (frame);
     }
 
-  if (s->display.nothing == 0)
+  if (f->display.nothing == 0)
     return Qnil;
 
-  alist = Fcopy_alist (s->param_alist);
-  store_in_alist (&alist, "name", s->name);
-  store_in_alist (&alist, "height", make_number (s->height));
-  store_in_alist (&alist, "width", make_number (s->width));
-  store_in_alist (&alist, "modeline", (s->wants_modeline ? Qt : Qnil));
+  alist = Fcopy_alist (f->param_alist);
+  store_in_alist (&alist, "name", f->name);
+  store_in_alist (&alist, "height", make_number (f->height));
+  store_in_alist (&alist, "width", make_number (f->width));
+  store_in_alist (&alist, "modeline", (f->wants_modeline ? Qt : Qnil));
   store_in_alist (&alist, "minibuffer",
-                  (SCREEN_HAS_MINIBUF (s)
-                   ? (SCREEN_MINIBUF_ONLY_P (s) ? intern ("only") : Qt)
-                   : SCREEN_MINIBUF_WINDOW (s)));
-  store_in_alist (&alist, "unsplittable", (s->no_split ? Qt : Qnil));
+                  (FRAME_HAS_MINIBUF (f)
+                   ? (FRAME_MINIBUF_ONLY_P (f) ? intern ("only") : Qt)
+                   : FRAME_MINIBUF_WINDOW (f)));
+  store_in_alist (&alist, "unsplittable", (f->no_split ? Qt : Qnil));
 
-  if (SCREEN_IS_X (s))
-    x_report_screen_params (s, &alist);
+  if (FRAME_IS_X (f))
+    x_report_frame_params (f, &alist);
   return alist;
 }
 
-DEFUN ("modify-screen-parameters", Fmodify_screen_parameters, 
-       Smodify_screen_parameters, 2, 2, 0,
-  "Modify the parameters of screen SCREEN according to ALIST.\n\
+DEFUN ("modify-frame-parameters", Fmodify_frame_parameters, 
+       Smodify_frame_parameters, 2, 2, 0,
+  "Modify the parameters of frame FRAME according to ALIST.\n\
 ALIST is an alist of parameters to change and their new values.\n\
 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.\n\
-The meaningful PARMs depend on the kind of screen; undefined PARMs are ignored.")
-  (screen, alist)
-     Lisp_Object screen, alist;
+The meaningful PARMs depend on the kind of frame; undefined PARMs are ignored.")
+  (frame, alist)
+     Lisp_Object frame, alist;
 {
-  register struct screen *s;
+  register struct frame *f;
   register Lisp_Object tail, elt, prop, val;
 
-  if (EQ (screen, Qnil))
-    s = selected_screen;
+  if (EQ (frame, Qnil))
+    f = selected_frame;
   else
     {
-      CHECK_LIVE_SCREEN (screen, 0);
-      s = XSCREEN (screen);
+      CHECK_LIVE_FRAME (frame, 0);
+      f = XFRAME (frame);
     }
 
-  if (SCREEN_IS_X (s))
+  if (FRAME_IS_X (f))
     for (tail = alist; !EQ (tail, Qnil); tail = Fcdr (tail))
       {
         elt = Fcar (tail);
         prop = Fcar (elt);
         val = Fcdr (elt);
-        x_set_screen_param (s, prop, val,
-                            get_screen_param (s, prop));
-        store_screen_param (s, prop, val);
+        x_set_frame_param (f, prop, val,
+                            get_frame_param (f, prop));
+        store_frame_param (f, prop, val);
       }
 
   return Qnil;
 }
 
 
-DEFUN ("screen-pixel-size", Fscreen_pixel_size, 
-       Sscreen_pixel_size, 1, 1, 0,
-  "Return a cons (width . height) of SCREEN's size in pixels.")
-  (screen)
-     Lisp_Object screen;
+DEFUN ("frame-pixel-size", Fframe_pixel_size, 
+       Sframe_pixel_size, 1, 1, 0,
+  "Return a cons (width . height) of FRAME's size in pixels.")
+  (frame)
+     Lisp_Object frame;
 {
-  register struct screen *s;
+  register struct frame *f;
   int width, height;
 
-  CHECK_LIVE_SCREEN (screen, 0);
-  s = XSCREEN (screen);
+  CHECK_LIVE_FRAME (frame, 0);
+  f = XFRAME (frame);
   
-  return Fcons (make_number (x_pixel_width (s)),
-                make_number (x_pixel_height (s)));
+  return Fcons (make_number (x_pixel_width (f)),
+                make_number (x_pixel_height (f)));
 }
 
-DEFUN ("screen-height", Fscreen_height, Sscreen_height, 0, 0, 0,
-  "Return number of lines available for display on selected screen.")
+DEFUN ("frame-height", Fframe_height, Sframe_height, 0, 0, 0,
+  "Return number of lines available for display on selected frame.")
   ()
 {
-  return make_number (SCREEN_HEIGHT (selected_screen));
+  return make_number (FRAME_HEIGHT (selected_frame));
 }
 
-DEFUN ("screen-width", Fscreen_width, Sscreen_width, 0, 0, 0,
-  "Return number of columns available for display on selected screen.")
+DEFUN ("frame-width", Fframe_width, Sframe_width, 0, 0, 0,
+  "Return number of columns available for display on selected frame.")
   ()
 {
-  return make_number (SCREEN_WIDTH (selected_screen));
+  return make_number (FRAME_WIDTH (selected_frame));
 }
 
-DEFUN ("set-screen-height", Fset_screen_height, Sset_screen_height, 2, 3, 0,
-  "Specify that the screen SCREEN has LINES lines.\n\
+DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
+  "Specify that the frame FRAME has LINES lines.\n\
 Optional third arg non-nil means that redisplay should use LINES lines\n\
-but that the idea of the actual height of the screen should not be changed.")
-  (screen, rows, pretend)
+but that the idea of the actual height of the frame should not be changed.")
+  (frame, rows, pretend)
      Lisp_Object rows, pretend;
 {
-  register struct screen *s;
+  register struct frame *f;
 
   CHECK_NUMBER (rows, 0);
-  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);
     }
 
-  if (SCREEN_IS_X (s))
+  if (FRAME_IS_X (f))
     {
-      if (XINT (rows) != s->width)
-        x_set_window_size (s, s->width, XINT (rows));
+      if (XINT (rows) != f->width)
+        x_set_window_size (f, f->width, XINT (rows));
     }
   else
-    change_screen_size (s, XINT (rows), 0, !NILP (pretend));
+    change_frame_size (f, XINT (rows), 0, !NILP (pretend));
   return Qnil;
 }
 
-DEFUN ("set-screen-width", Fset_screen_width, Sset_screen_width, 2, 3, 0,
-  "Specify that the screen SCREEN has COLS columns.\n\
+DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 3, 0,
+  "Specify that the frame FRAME has COLS columns.\n\
 Optional third arg non-nil means that redisplay should use COLS columns\n\
-but that the idea of the actual width of the screen should not be changed.")
-  (screen, cols, pretend)
+but that the idea of the actual width of the frame should not be changed.")
+  (frame, cols, pretend)
      Lisp_Object cols, pretend;
 {
-  register struct screen *s;
+  register struct frame *f;
   CHECK_NUMBER (cols, 0);
-  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);
     }
 
-  if (SCREEN_IS_X (s))
+  if (FRAME_IS_X (f))
     {
-      if (XINT (cols) != s->width)
-        x_set_window_size (s, XINT (cols), s->height);
+      if (XINT (cols) != f->width)
+        x_set_window_size (f, XINT (cols), f->height);
     }
   else
-    change_screen_size (selected_screen, 0, XINT (cols), !NILP (pretend));
+    change_frame_size (selected_frame, 0, XINT (cols), !NILP (pretend));
   return Qnil;
 }
 
-DEFUN ("set-screen-size", Fset_screen_size, Sset_screen_size, 3, 3, 0,
-  "Sets size of SCREEN to COLS by ROWS, measured in characters.")
-  (screen, cols, rows)
-     Lisp_Object screen, cols, rows;
+DEFUN ("set-frame-size", Fset_frame_size, Sset_frame_size, 3, 3, 0,
+  "Sets size of FRAME to COLS by ROWS, measured in characters.")
+  (frame, cols, rows)
+     Lisp_Object frame, cols, rows;
 {
-  register struct screen *s;
+  register struct frame *f;
   int mask;
 
-  CHECK_LIVE_SCREEN (screen, 0);
+  CHECK_LIVE_FRAME (frame, 0);
   CHECK_NUMBER (cols, 2);
   CHECK_NUMBER (rows, 1);
-  s = XSCREEN (screen);
+  f = XFRAME (frame);
 
-  if (SCREEN_IS_X (s))
+  if (FRAME_IS_X (f))
     {
-      if (XINT (rows) != s->height || XINT (cols) != s->width)
-        x_set_window_size (s, XINT (cols), XINT (rows));
+      if (XINT (rows) != f->height || XINT (cols) != f->width)
+        x_set_window_size (f, XINT (cols), XINT (rows));
     }
   else
-    change_screen_size (s, XINT (rows), XINT (cols), 0);
+    change_frame_size (f, XINT (rows), XINT (cols), 0);
 
   return Qnil;
 }
 
-DEFUN ("set-screen-position", Fset_screen_position, 
-       Sset_screen_position, 3, 3, 0,
-  "Sets position of SCREEN in pixels to XOFFSET by YOFFSET.\n\
+DEFUN ("set-frame-position", Fset_frame_position, 
+       Sset_frame_position, 3, 3, 0,
+  "Sets position of FRAME in pixels to XOFFSET by YOFFSET.\n\
 If XOFFSET or YOFFSET are negative, they are interpreted relative to\n\
-the leftmost or bottommost position SCREEN could occupy without going\n\
-off the screen.")
-  (screen, xoffset, yoffset)
-     Lisp_Object screen, xoffset, yoffset;
+the leftmost or bottommost position FRAME could occupy without going\n\
+off the frame.")
+  (frame, xoffset, yoffset)
+     Lisp_Object frame, xoffset, yoffset;
 {
-  register struct screen *s;
+  register struct frame *f;
   int mask;
 
-  CHECK_LIVE_SCREEN (screen, 0);
+  CHECK_LIVE_FRAME (frame, 0);
   CHECK_NUMBER (xoffset, 1);
   CHECK_NUMBER (yoffset, 2);
-  s = XSCREEN (screen);
+  f = XFRAME (frame);
 
-  if (SCREEN_IS_X (s))
-    x_set_offset (s, XINT (xoffset), XINT (yoffset));
+  if (FRAME_IS_X (f))
+    x_set_offset (f, XINT (xoffset), XINT (yoffset));
 
   return Qt;
 }
@@ -1088,14 +1088,14 @@ off the screen.")
 #ifndef HAVE_X11
 DEFUN ("rubber-band-rectangle", Frubber_band_rectangle, Srubber_band_rectangle,
        3, 3, "",
-  "Ask user to specify a window position and size on SCREEN with the mouse.\n\
-Arguments are SCREEN, NAME and GEO.  NAME is a name to be displayed as\n\
+  "Ask user to specify a window position and size on FRAME with the mouse.\n\
+Arguments are FRAME, NAME and GEO.  NAME is a name to be displayed as\n\
 the purpose of this rectangle.  GEO is an X-windows size spec that can\n\
 specify defaults for some sizes/positions.  If GEO specifies everything,\n\
 the mouse is not used.\n\
-Returns a list of five values: (SCREEN LEFT TOP WIDTH HEIGHT).")
-  (screen, name, geo)
-     Lisp_Object screen;
+Returns a list of five values: (FRAME LEFT TOP WIDTH HEIGHT).")
+  (frame, name, geo)
+     Lisp_Object frame;
      Lisp_Object name;
      Lisp_Object geo;
 {
@@ -1103,14 +1103,14 @@ Returns a list of five values: (SCREEN LEFT TOP WIDTH HEIGHT).")
   Lisp_Object nums[4];
   int i;
 
-  CHECK_SCREEN (screen, 0);
+  CHECK_FRAME (frame, 0);
   CHECK_STRING (name, 1);
   CHECK_STRING (geo, 2);
 
-  switch (XSCREEN (screen)->output_method)
+  switch (XFRAME (frame)->output_method)
     {
     case output_x_window:
-      x_rubber_band (XSCREEN (screen), &vals[0], &vals[1], &vals[2], &vals[3],
+      x_rubber_band (XFRAME (frame), &vals[0], &vals[1], &vals[2], &vals[3],
                      XSTRING (geo)->data, XSTRING (name)->data);
       break;
 
@@ -1120,102 +1120,102 @@ Returns a list of five values: (SCREEN LEFT TOP WIDTH HEIGHT).")
 
   for (i = 0; i < 4; i++)
     XFASTINT (nums[i]) = vals[i];
-  return Fcons (screen, Flist (4, nums));
+  return Fcons (frame, Flist (4, nums));
   return Qnil;
 }
 #endif /* not HAVE_X11 */
 
-choose_minibuf_screen ()
+choose_minibuf_frame ()
 {
-  /* For lowest-level minibuf, put it on currently selected screen
-     if screen has a minibuffer.  */
+  /* For lowest-level minibuf, put it on currently selected frame
+     if frame has a minibuffer.  */
   if (minibuf_level == 0
-      && selected_screen != 0
-      && !EQ (minibuf_window, selected_screen->minibuffer_window)
-      && !EQ (Qnil, selected_screen->minibuffer_window))
+      && selected_frame != 0
+      && !EQ (minibuf_window, selected_frame->minibuffer_window)
+      && !EQ (Qnil, selected_frame->minibuffer_window))
     {
-      Fset_window_buffer (selected_screen->minibuffer_window,
+      Fset_window_buffer (selected_frame->minibuffer_window,
                           XWINDOW (minibuf_window)->buffer);
-      minibuf_window = selected_screen->minibuffer_window;
+      minibuf_window = selected_frame->minibuffer_window;
     }
 }
 
-syms_of_screen ()
+syms_of_frame ()
 {
-  Qscreenp = intern ("screenp");
-  Qlive_screen_p = intern ("live_screen_p");
+  Qframep = intern ("framep");
+  Qlive_frame_p = intern ("live_frame_p");
   Qminibuffer = intern ("minibuffer");
 
-  staticpro (&Qscreenp);
-  staticpro (&Qlive_screen_p);
+  staticpro (&Qframep);
+  staticpro (&Qlive_frame_p);
   staticpro (&Qminibuffer);
 
-  staticpro (&Vscreen_list);
+  staticpro (&Vframe_list);
 
-  DEFVAR_LISP ("terminal-screen", &Vterminal_screen,
-    "The initial screen-object, which represents Emacs's stdout.");
+  DEFVAR_LISP ("terminal-frame", &Vterminal_frame,
+    "The initial frame-object, which represents Emacs's stdout.");
 
   DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified,
-    "Non-nil if all of emacs is iconified and screen updates are not needed.");
+    "Non-nil if all of emacs is iconified and frame updates are not needed.");
   Vemacs_iconified = Qnil;
 
-  DEFVAR_LISP ("default-minibuffer-screen", &Vdefault_minibuffer_screen,
-    "Minibufferless screens use this screen's minibuffer.\n\
+  DEFVAR_LISP ("default-minibuffer-frame", &Vdefault_minibuffer_frame,
+    "Minibufferless frames use this frame's minibuffer.\n\
 \n\
-Emacs cannot create minibufferless screens unless this is set to an\n\
+Emacs cannot create minibufferless frames unless this is set to an\n\
 appropriate surrogate.\n\
 \n\
 Emacs consults this variable only when creating minibufferless\n\
-screens; once the screen is created, it sticks with its assigned\n\
+frames; once the frame is created, it sticks with its assigned\n\
 minibuffer, no matter what this variable is set to.  This means that\n\
 this variable doesn't necessarily say anything meaningful about the\n\
-current set of screens, or where the minibuffer is currently being\n\
+current set of frames, or where the minibuffer is currently being\n\
 displayed.");
-  Vdefault_minibuffer_screen = Qnil;
+  Vdefault_minibuffer_frame = Qnil;
 
-  DEFVAR_LISP ("default-screen-alist", &Vdefault_screen_alist,
-    "Alist of default values for screen creation.\n\
+  DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist,
+    "Alist of default values for frame creation.\n\
 These may be set in your init file, like this:\n\
-  (setq default-screen-alist '((width . 80) (height . 55)))\n\
+  (setq default-frame-alist '((width . 80) (height . 55)))\n\
 These override values given in window system configuration data, like\n\
 X Windows' defaults database.\n\
-For values specific to the first Emacs screen, see `initial-screen-alist'.\n\
-For values specific to the separate minibuffer screen, see\n\
-`minibuffer-screen-alist'.");
-  Vdefault_screen_alist = Qnil;
-
-  defsubr (&Sscreenp);
-  defsubr (&Slive_screen_p);
-  defsubr (&Sselect_screen);
-  defsubr (&Sselected_screen);
-  defsubr (&Swindow_screen);
-  defsubr (&Sscreen_root_window);
-  defsubr (&Sscreen_selected_window);
-  defsubr (&Sscreen_list);
-  defsubr (&Snext_screen);
-  defsubr (&Sdelete_screen);
+For values specific to the first Emacs frame, see `initial-frame-alist'.\n\
+For values specific to the separate minibuffer frame, see\n\
+`minibuffer-frame-alist'.");
+  Vdefault_frame_alist = Qnil;
+
+  defsubr (&Sframep);
+  defsubr (&Slive_frame_p);
+  defsubr (&Sselect_frame);
+  defsubr (&Sselected_frame);
+  defsubr (&Swindow_frame);
+  defsubr (&Sframe_root_window);
+  defsubr (&Sframe_selected_window);
+  defsubr (&Sframe_list);
+  defsubr (&Snext_frame);
+  defsubr (&Sdelete_frame);
   defsubr (&Smouse_position);
   defsubr (&Sset_mouse_position);
 #if 0
-  defsubr (&Sscreen_configuration);
-  defsubr (&Srestore_screen_configuration);
+  defsubr (&Sframe_configuration);
+  defsubr (&Srestore_frame_configuration);
 #endif
-  defsubr (&Smake_screen_visible);
-  defsubr (&Smake_screen_invisible);
-  defsubr (&Siconify_screen);
-  defsubr (&Sscreen_visible_p);
-  defsubr (&Svisible_screen_list);
-  defsubr (&Sredirect_screen_focus);
-  defsubr (&Sscreen_focus);
-  defsubr (&Sscreen_parameters);
-  defsubr (&Smodify_screen_parameters);
-  defsubr (&Sscreen_pixel_size);
-  defsubr (&Sscreen_height);
-  defsubr (&Sscreen_width);
-  defsubr (&Sset_screen_height);
-  defsubr (&Sset_screen_width);
-  defsubr (&Sset_screen_size);
-  defsubr (&Sset_screen_position);
+  defsubr (&Smake_frame_visible);
+  defsubr (&Smake_frame_invisible);
+  defsubr (&Siconify_frame);
+  defsubr (&Sframe_visible_p);
+  defsubr (&Svisible_frame_list);
+  defsubr (&Sredirect_frame_focus);
+  defsubr (&Sframe_focus);
+  defsubr (&Sframe_parameters);
+  defsubr (&Smodify_frame_parameters);
+  defsubr (&Sframe_pixel_size);
+  defsubr (&Sframe_height);
+  defsubr (&Sframe_width);
+  defsubr (&Sset_frame_height);
+  defsubr (&Sset_frame_width);
+  defsubr (&Sset_frame_size);
+  defsubr (&Sset_frame_position);
 #ifndef HAVE_X11
   defsubr (&Srubber_band_rectangle);
 #endif  /* HAVE_X11 */
diff --git a/src/frame.h b/src/frame.h
index f9e270e52c5..faf3000b2d2 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -1,4 +1,4 @@
-/* Define screen-object for GNU Emacs.
+/* Define frame-object for GNU Emacs.
    Copyright (C) 1988, 1992 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -18,132 +18,132 @@ along with GNU Emacs; see the file COPYING.  If not, write to
 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 
-/* The structure representing a screen.
+/* The structure representing a frame.
 
-   We declare this even if MULTI_SCREEN is not defined, because when
-   we lack multi-screen support, we use one instance of this structure
-   to represent the one screen we support.  This is cleaner than
+   We declare this even if MULTI_FRAME is not defined, because when
+   we lack multi-frame support, we use one instance of this structure
+   to represent the one frame we support.  This is cleaner than
    having miscellaneous random variables scattered about.  */
 
 enum output_method
 { output_termcap, output_x_window };
 
-struct screen
+struct frame
 {
   int size;
   struct Lisp_Vector *next;
 
-  /* glyphs as they appear on the screen */
-  struct screen_glyphs *current_glyphs;
+  /* glyphs as they appear on the frame */
+  struct frame_glyphs *current_glyphs;
 
-  /* glyphs we'd like to appear on the screen */
-  struct screen_glyphs *desired_glyphs;
+  /* glyphs we'd like to appear on the frame */
+  struct frame_glyphs *desired_glyphs;
 
   /* See do_line_insertion_deletion_costs for info on these arrays. */
-  /* Cost of inserting 1 line on this screen */
+  /* Cost of inserting 1 line on this frame */
   int *insert_line_cost;
-  /* Cost of deleting 1 line on this screen */
+  /* Cost of deleting 1 line on this frame */
   int *delete_line_cost;
-  /* Cost of inserting n lines on this screen */
+  /* Cost of inserting n lines on this frame */
   int *insert_n_lines_cost;
-  /* Cost of deleting n lines on this screen */
+  /* Cost of deleting n lines on this frame */
   int *delete_n_lines_cost;
 
   /* glyphs for the mode line */
-  struct screen_glyphs *temp_glyphs;
+  struct frame_glyphs *temp_glyphs;
 
-  /* Intended cursor position of this screen.
+  /* Intended cursor position of this frame.
      Measured in characters, counting from upper left corner
-     within the screen.  */
+     within the frame.  */
   int cursor_x;
   int cursor_y;
 
-  /* Actual cursor position of this screen, and the character under it.
-     (Not used for terminal screens.)  */
+  /* Actual cursor position of this frame, and the character under it.
+     (Not used for terminal frames.)  */
   int phys_cursor_x;
   int phys_cursor_y;
   /* This is handy for undrawing the cursor, because current_glyphs is
      not always accurate when in do_scrolling.  */
   GLYPH phys_cursor_glyph;
 
-  /* Size of this screen, in units of characters.  */
+  /* Size of this frame, in units of characters.  */
   int height;
   int width;
 
   /* New height and width for pending size change.  0 if no change pending.  */
   int new_height, new_width;
 
-  /* Name of this screen: a Lisp string.  */
+  /* Name of this frame: a Lisp string.  */
   Lisp_Object name;
 
-  /* The screen which should recieve keystrokes that occur in this
-     screen.  This is usually the screen itself, but if the screen is
-     minibufferless, this points to the minibuffer screen when it is
+  /* The frame which should recieve keystrokes that occur in this
+     frame.  This is usually the frame itself, but if the frame is
+     minibufferless, this points to the minibuffer frame when it is
      active.  */
-  Lisp_Object focus_screen;
+  Lisp_Object focus_frame;
 
-  /* This screen's root window.  Every screen has one.
-     If the screen has only a minibuffer window, this is it.
-     Otherwise, if the screen has a minibuffer window, this is its sibling.  */
+  /* This frame's root window.  Every frame has one.
+     If the frame has only a minibuffer window, this is it.
+     Otherwise, if the frame has a minibuffer window, this is its sibling.  */
   Lisp_Object root_window;
 
-  /* This screen's selected window.
-     Each screen has its own window hierarchy
-     and one of the windows in it is selected within the screen.
-     The selected window of the selected screen is Emacs's selected window.  */
+  /* This frame's selected window.
+     Each frame has its own window hierarchy
+     and one of the windows in it is selected within the frame.
+     The selected window of the selected frame is Emacs's selected window.  */
   Lisp_Object selected_window;
 
-  /* This screen's minibuffer window.
-     Most screens have their own minibuffer windows,
-     but only the selected screen's minibuffer window
+  /* This frame's minibuffer window.
+     Most frames have their own minibuffer windows,
+     but only the selected frame's minibuffer window
      can actually appear to exist.  */
   Lisp_Object minibuffer_window;
 
-  /* Parameter alist of this screen.
-     These are the parameters specified when creating the screen
-     or modified with modify-screen-parameters.  */
+  /* Parameter alist of this frame.
+     These are the parameters specified when creating the frame
+     or modified with modify-frame-parameters.  */
   Lisp_Object param_alist;
 
-  /* The output method says how the contents of this screen
+  /* The output method says how the contents of this frame
      are displayed.  It could be using termcap, or using an X window.  */
   enum output_method output_method;
 
   /* A structure of auxiliary data used for displaying the contents.
-     struct x_display is used for X window screens;
+     struct x_display is used for X window frames;
      it is defined in xterm.h.  */
   union display { struct x_display *x; int nothing; } display;
 
-  /* Nonzero if last attempt at redisplay on this screen was preempted.  */
+  /* Nonzero if last attempt at redisplay on this frame was preempted.  */
   char display_preempted;
 
-  /* Nonzero if screen is currently displayed.  */
+  /* Nonzero if frame is currently displayed.  */
   char visible;
 
   /* Nonzero if window is currently iconified.
      This and visible are mutually exclusive.  */
   char iconified;
 
-  /* Nonzero if this screen should be redrawn.  */
+  /* Nonzero if this frame should be redrawn.  */
   char garbaged;
 
-  /* True if screen actually has a minibuffer window on it.
-     0 if using a minibuffer window that isn't on this screen.  */
+  /* True if frame actually has a minibuffer window on it.
+     0 if using a minibuffer window that isn't on this frame.  */
   char has_minibuffer;
      
-  /* 0 means, if this screen has just one window,
+  /* 0 means, if this frame has just one window,
      show no modeline for that window.  */
   char wants_modeline;
 
-  /* Non-0 means raise this screen to the top of the heap when selected.  */
+  /* Non-0 means raise this frame to the top of the heap when selected.  */
   char auto_raise;
 
-  /* Non-0 means lower this screen to the bottom of the stack when left.  */
+  /* Non-0 means lower this frame to the bottom of the stack when left.  */
   char auto_lower;
 
-  /* True if screen's root window can't be split.  */
+  /* True if frame's root window can't be split.  */
   char no_split;
 
-  /* Storage for messages to this screen. */
+  /* Storage for messages to this frame. */
   char *message_buf;
 
   /* Nonnegative if current redisplay should not do scroll computation
@@ -151,162 +151,162 @@ struct screen
   int scroll_bottom_vpos;
 };
 
-#ifdef MULTI_SCREEN
-
-typedef struct screen *SCREEN_PTR;
-
-#define XSCREEN(p) ((struct screen *) XPNTR (p))
-#define XSETSCREEN(p, v) ((struct screen *) XSETPNTR (p, v))
-
-#define WINDOW_SCREEN(w) (w)->screen
-
-#define SCREENP(s) (XTYPE(s) == Lisp_Screen)
-#define SCREEN_LIVE_P(s) ((s)->display.nothing != 0)
-#define SCREEN_IS_TERMCAP(s) ((s)->output_method == output_termcap)
-#define SCREEN_IS_X(s) ((s)->output_method == output_x_window)
-#define SCREEN_MINIBUF_ONLY_P(s) \
-  EQ (SCREEN_ROOT_WINDOW (s), SCREEN_MINIBUF_WINDOW (s))
-#define SCREEN_HAS_MINIBUF(s) ((s)->has_minibuffer)
-#define SCREEN_CURRENT_GLYPHS(s) (s)->current_glyphs
-#define SCREEN_DESIRED_GLYPHS(s) (s)->desired_glyphs
-#define SCREEN_TEMP_GLYPHS(s) (s)->temp_glyphs
-#define SCREEN_HEIGHT(s) (s)->height
-#define SCREEN_WIDTH(s) (s)->width
-#define SCREEN_NEW_HEIGHT(s) (s)->new_height
-#define SCREEN_NEW_WIDTH(s) (s)->new_width
-#define SCREEN_CURSOR_X(s) (s)->cursor_x
-#define SCREEN_CURSOR_Y(s) (s)->cursor_y
-#define SCREEN_VISIBLE_P(s) (s)->visible
-#define SET_SCREEN_GARBAGED(s) (screen_garbaged = 1, s->garbaged = 1)
-#define SCREEN_GARBAGED_P(s) (s)->garbaged
-#define SCREEN_NO_SPLIT_P(s) (s)->no_split
-#define SCREEN_WANTS_MODELINE_P(s) (s)->wants_modeline
-#define SCREEN_ICONIFIED_P(s) (s)->iconified
-#define SCREEN_MINIBUF_WINDOW(s) (s)->minibuffer_window
-#define SCREEN_ROOT_WINDOW(s) (s)->root_window
-#define SCREEN_SELECTED_WINDOW(s) (s)->selected_window
-#define SET_GLYPHS_SCREEN(glyphs,screen) ((glyphs)->screen = (screen))
-#define SCREEN_INSERT_COST(s) (s)->insert_line_cost    
-#define SCREEN_DELETE_COST(s) (s)->delete_line_cost    
-#define SCREEN_INSERTN_COST(s) (s)->insert_n_lines_cost
-#define SCREEN_DELETEN_COST(s) (s)->delete_n_lines_cost
-#define SCREEN_MESSAGE_BUF(s) (s)->message_buf
-#define SCREEN_SCROLL_BOTTOM_VPOS(s) (s)->scroll_bottom_vpos
-#define SCREEN_FOCUS_SCREEN(s) (s)->focus_screen
-
-#define CHECK_SCREEN(x, i)                              \
+#ifdef MULTI_FRAME
+
+typedef struct frame *FRAME_PTR;
+
+#define XFRAME(p) ((struct frame *) XPNTR (p))
+#define XSETFRAME(p, v) ((struct frame *) XSETPNTR (p, v))
+
+#define WINDOW_FRAME(w) (w)->frame
+
+#define FRAMEP(f) (XTYPE(f) == Lisp_Frame)
+#define FRAME_LIVE_P(f) ((f)->display.nothing != 0)
+#define FRAME_IS_TERMCAP(f) ((f)->output_method == output_termcap)
+#define FRAME_IS_X(f) ((f)->output_method == output_x_window)
+#define FRAME_MINIBUF_ONLY_P(f) \
+  EQ (FRAME_ROOT_WINDOW (f), FRAME_MINIBUF_WINDOW (f))
+#define FRAME_HAS_MINIBUF(f) ((f)->has_minibuffer)
+#define FRAME_CURRENT_GLYPHS(f) (f)->current_glyphs
+#define FRAME_DESIRED_GLYPHS(f) (f)->desired_glyphs
+#define FRAME_TEMP_GLYPHS(f) (f)->temp_glyphs
+#define FRAME_HEIGHT(f) (f)->height
+#define FRAME_WIDTH(f) (f)->width
+#define FRAME_NEW_HEIGHT(f) (f)->new_height
+#define FRAME_NEW_WIDTH(f) (f)->new_width
+#define FRAME_CURSOR_X(f) (f)->cursor_x
+#define FRAME_CURSOR_Y(f) (f)->cursor_y
+#define FRAME_VISIBLE_P(f) (f)->visible
+#define SET_FRAME_GARBAGED(f) (frame_garbaged = 1, f->garbaged = 1)
+#define FRAME_GARBAGED_P(f) (f)->garbaged
+#define FRAME_NO_SPLIT_P(f) (f)->no_split
+#define FRAME_WANTS_MODELINE_P(f) (f)->wants_modeline
+#define FRAME_ICONIFIED_P(f) (f)->iconified
+#define FRAME_MINIBUF_WINDOW(f) (f)->minibuffer_window
+#define FRAME_ROOT_WINDOW(f) (f)->root_window
+#define FRAME_SELECTED_WINDOW(f) (f)->selected_window
+#define SET_GLYPHS_FRAME(glyphs,frame) ((glyphs)->frame = (frame))
+#define FRAME_INSERT_COST(f) (f)->insert_line_cost    
+#define FRAME_DELETE_COST(f) (f)->delete_line_cost    
+#define FRAME_INSERTN_COST(f) (f)->insert_n_lines_cost
+#define FRAME_DELETEN_COST(f) (f)->delete_n_lines_cost
+#define FRAME_MESSAGE_BUF(f) (f)->message_buf
+#define FRAME_SCROLL_BOTTOM_VPOS(f) (f)->scroll_bottom_vpos
+#define FRAME_FOCUS_FRAME(f) (f)->focus_frame
+
+#define CHECK_FRAME(x, i)                               \
   {                                                     \
-    if (! SCREENP (x))                                  \
-      x = wrong_type_argument (Qscreenp, (x));          \
+    if (! FRAMEP (x))                                   \
+      x = wrong_type_argument (Qframep, (x));           \
   }
 
-#define CHECK_LIVE_SCREEN(x, i)                         \
+#define CHECK_LIVE_FRAME(x, i)                          \
   {                                                     \
-    if (! SCREENP (x)                                   \
-        || ! SCREEN_LIVE_P (XSCREEN (x)))               \
-      x = wrong_type_argument (Qlive_screen_p, (x));    \
+    if (! FRAMEP (x)                                    \
+        || ! FRAME_LIVE_P (XFRAME (x)))         \
+      x = wrong_type_argument (Qlive_frame_p, (x));     \
   }
 
-/* FOR_EACH_SCREEN (LIST_VAR, SCREEN_VAR) followed by a statement is a
-   `for' loop which iterates over the elements of Vscreen_list.  The
-   loop will set SCREEN_VAR, a SCREEN_PTR, to each screen in
-   Vscreen_list in succession and execute the statement.  LIST_VAR
+/* FOR_EACH_FRAME (LIST_VAR, FRAME_VAR) followed by a statement is a
+   `for' loop which iterates over the elements of Vframe_list.  The
+   loop will set FRAME_VAR, a FRAME_PTR, to each frame in
+   Vframe_list in succession and execute the statement.  LIST_VAR
    should be a Lisp_Object; it is used to iterate through the
-   Vscreen_list.  
+   Vframe_list.  
 
-   If MULTI_SCREEN isn't defined, then this loop expands to something which 
+   If MULTI_FRAME isn't defined, then this loop expands to something which 
    executes the statement once.  */
-#define FOR_EACH_SCREEN(list_var, screen_var)                   \
-  for ((list_var) = Vscreen_list;                               \
+#define FOR_EACH_FRAME(list_var, frame_var)                     \
+  for ((list_var) = Vframe_list;                                \
        (CONSP (list_var)                                        \
-        && (screen_var = XSCREEN (XCONS (list_var)->car), 1));  \
+        && (frame_var = XFRAME (XCONS (list_var)->car), 1));    \
        list_var = XCONS (list_var)->cdr)
 
 
-extern Lisp_Object Qscreenp, Qlive_screen_p;
+extern Lisp_Object Qframep, Qlive_frame_p;
 
-extern struct screen *selected_screen;
-extern struct screen *last_nonminibuf_screen;
+extern struct frame *selected_frame;
+extern struct frame *last_nonminibuf_frame;
 
-extern struct screen *make_terminal_screen ();
-extern struct screen *make_screen ();
-extern struct screen *make_minibuffer_screen ();
-extern struct screen *make_screen_without_minibuffer ();
+extern struct frame *make_terminal_frame ();
+extern struct frame *make_frame ();
+extern struct frame *make_minibuffer_frame ();
+extern struct frame *make_frame_without_minibuffer ();
 
-/* Nonzero means SCREEN_MESSAGE_BUF (selected_screen) is being used by
+/* Nonzero means FRAME_MESSAGE_BUF (selected_frame) is being used by
    print.  */
 extern int message_buf_print;
 
-extern Lisp_Object Vscreen_list;
-extern Lisp_Object Vdefault_screen_alist;
+extern Lisp_Object Vframe_list;
+extern Lisp_Object Vdefault_frame_alist;
 
-extern Lisp_Object Vterminal_screen;
+extern Lisp_Object Vterminal_frame;
 
-#else /* not MULTI_SCREEN */
+#else /* not MULTI_FRAME */
 
-/* These definitions are used in a single-screen version of Emacs.  */
+/* These definitions are used in a single-frame version of Emacs.  */
 
-#define SCREEN_PTR int
+#define FRAME_PTR int
 
-extern struct screen the_only_screen;
+extern struct frame the_only_frame;
 
-extern int selected_screen;
-extern int last_nonminibuf_screen;
+extern int selected_frame;
+extern int last_nonminibuf_frame;
 
-/* Nonzero means SCREEN_MESSAGE_BUF (selected_screen) is being used by
+/* Nonzero means FRAME_MESSAGE_BUF (selected_frame) is being used by
    print.  */
 extern int message_buf_print;
 
-#define XSCREEN(s) selected_screen
-#define WINDOW_SCREEN(w) selected_screen
-
-#define SCREENP(s) (XTYPE(s) == Lisp_Screen)
-#define SCREEN_LIVE_P(s) 1
-#define SCREEN_IS_TERMCAP(s) 1
-#define SCREEN_IS_X(s) 0
-#define SCREEN_MINIBUF_ONLY_P(s) 0
-#define SCREEN_HAS_MINIBUF(s) 1
-#define SCREEN_CURRENT_GLYPHS(s) the_only_screen.current_glyphs
-#define SCREEN_DESIRED_GLYPHS(s) the_only_screen.desired_glyphs
-#define SCREEN_TEMP_GLYPHS(s) the_only_screen.temp_glyphs
-#define SCREEN_HEIGHT(s) the_only_screen.height
-#define SCREEN_WIDTH(s) the_only_screen.width
-#define SCREEN_NEW_HEIGHT(s) the_only_screen.new_height
-#define SCREEN_NEW_WIDTH(s) the_only_screen.new_width
-#define SCREEN_CURSOR_X(s) the_only_screen.cursor_x
-#define SCREEN_CURSOR_Y(s) the_only_screen.cursor_y
-#define SCREEN_VISIBLE_P(s) 1
-#define SET_SCREEN_GARBAGED(s) (screen_garbaged = 1)
-#define SCREEN_GARBAGED_P(s) screen_garbaged
-#define SCREEN_NO_SPLIT_P(s) 0
-#define SCREEN_WANTS_MODELINE_P(s) 1
-#define SCREEN_ICONIFIED_P(s) 0
-#define SCREEN_MINIBUF_WINDOW(s) minibuf_window
-#define SCREEN_ROOT_WINDOW(s) the_only_screen.root_window
-#define SCREEN_SELECTED_WINDOW(s) selected_window
-#define SET_GLYPHS_SCREEN(glyphs,screen)
-#define SCREEN_INSERT_COST(screen)  the_only_screen.insert_line_cost    
-#define SCREEN_DELETE_COST(screen)  the_only_screen.delete_line_cost    
-#define SCREEN_INSERTN_COST(screen) the_only_screen.insert_n_lines_cost
-#define SCREEN_DELETEN_COST(screen) the_only_screen.delete_n_lines_cost
-#define SCREEN_MESSAGE_BUF(s) the_only_screen.message_buf
-#define SCREEN_SCROLL_BOTTOM_VPOS(s) the_only_screen.scroll_bottom_vpos
-#define SCREEN_FOCUS_SCREEN(s) 0
-
-#define CHECK_SCREEN(x, i) { ; }
-#define CHECK_LIVE_SCREEN(x, y) { ; }
-
-/* FOR_EACH_SCREEN (LIST_VAR, SCREEN_VAR) followed by a statement is a
-   `for' loop which iterates over the elements of Vscreen_list.  The
-   loop will set SCREEN_VAR, a SCREEN_PTR, to each screen in
-   Vscreen_list in succession and execute the statement.  LIST_VAR
+#define XFRAME(f) selected_frame
+#define WINDOW_FRAME(w) selected_frame
+
+#define FRAMEP(f) (XTYPE(f) == Lisp_Frame)
+#define FRAME_LIVE_P(f) 1
+#define FRAME_IS_TERMCAP(f) 1
+#define FRAME_IS_X(f) 0
+#define FRAME_MINIBUF_ONLY_P(f) 0
+#define FRAME_HAS_MINIBUF(f) 1
+#define FRAME_CURRENT_GLYPHS(f) the_only_frame.current_glyphs
+#define FRAME_DESIRED_GLYPHS(f) the_only_frame.desired_glyphs
+#define FRAME_TEMP_GLYPHS(f) the_only_frame.temp_glyphs
+#define FRAME_HEIGHT(f) the_only_frame.height
+#define FRAME_WIDTH(f) the_only_frame.width
+#define FRAME_NEW_HEIGHT(f) the_only_frame.new_height
+#define FRAME_NEW_WIDTH(f) the_only_frame.new_width
+#define FRAME_CURSOR_X(f) the_only_frame.cursor_x
+#define FRAME_CURSOR_Y(f) the_only_frame.cursor_y
+#define FRAME_VISIBLE_P(f) 1
+#define SET_FRAME_GARBAGED(f) (frame_garbaged = 1)
+#define FRAME_GARBAGED_P(f) frame_garbaged
+#define FRAME_NO_SPLIT_P(f) 0
+#define FRAME_WANTS_MODELINE_P(f) 1
+#define FRAME_ICONIFIED_P(f) 0
+#define FRAME_MINIBUF_WINDOW(f) minibuf_window
+#define FRAME_ROOT_WINDOW(f) the_only_frame.root_window
+#define FRAME_SELECTED_WINDOW(f) selected_window
+#define SET_GLYPHS_FRAME(glyphs,frame)
+#define FRAME_INSERT_COST(frame)  the_only_frame.insert_line_cost    
+#define FRAME_DELETE_COST(frame)  the_only_frame.delete_line_cost    
+#define FRAME_INSERTN_COST(frame) the_only_frame.insert_n_lines_cost
+#define FRAME_DELETEN_COST(frame) the_only_frame.delete_n_lines_cost
+#define FRAME_MESSAGE_BUF(f) the_only_frame.message_buf
+#define FRAME_SCROLL_BOTTOM_VPOS(f) the_only_frame.scroll_bottom_vpos
+#define FRAME_FOCUS_FRAME(f) 0
+
+#define CHECK_FRAME(x, i) { ; }
+#define CHECK_LIVE_FRAME(x, y) { ; }
+
+/* FOR_EACH_FRAME (LIST_VAR, FRAME_VAR) followed by a statement is a
+   `for' loop which iterates over the elements of Vframe_list.  The
+   loop will set FRAME_VAR, a FRAME_PTR, to each frame in
+   Vframe_list in succession and execute the statement.  LIST_VAR
    should be a Lisp_Object; it is used to iterate through the
-   Vscreen_list.  
+   Vframe_list.  
 
-   If MULTI_SCREEN _is_ defined, then this loop expands to a real
-   `for' loop which traverses Vscreen_list using LIST_VAR and
-   SCREEN_VAR.  */
-#define FOR_EACH_SCREEN(list_var, screen_var)                   \
-  for (screen_var = (SCREEN_PTR) 1; screen_var; screen_var = (SCREEN_PTR) 0)
+   If MULTI_FRAME _is_ defined, then this loop expands to a real
+   `for' loop which traverses Vframe_list using LIST_VAR and
+   FRAME_VAR.  */
+#define FOR_EACH_FRAME(list_var, frame_var)                     \
+  for (frame_var = (FRAME_PTR) 1; frame_var; frame_var = (FRAME_PTR) 0)
 
-#endif /* not MULTI_SCREEN */
+#endif /* not MULTI_FRAME */
diff --git a/src/keyboard.c b/src/keyboard.c
index cb2e56adf36..442a4f318ea 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -28,7 +28,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "lisp.h"
 #include "termhooks.h"
 #include "macros.h"
-#include "screen.h"
+#include "frame.h"
 #include "window.h"
 #include "commands.h"
 #include "buffer.h"
@@ -191,24 +191,24 @@ extern Lisp_Object Vmouse_event;
 /* Hook to call on each mouse event after running its definition.  */
 Lisp_Object Vmouse_event_function;
 
-/* Hook to call when mouse leaves screen.  */
+/* Hook to call when mouse leaves frame.  */
 Lisp_Object Vmouse_left_hook;
 
-/* Hook to call when a screen is mapped.  */
-Lisp_Object Vmap_screen_hook;
+/* Hook to call when a frame is mapped.  */
+Lisp_Object Vmap_frame_hook;
 
-/* Hook to call when a screen is unmapped.  */
-Lisp_Object Vunmap_screen_hook;
+/* Hook to call when a frame is unmapped.  */
+Lisp_Object Vunmap_frame_hook;
 
 /* Handler for non-grabbed (no keys depressed) mouse motion.  */
 Lisp_Object Vmouse_motion_handler;
 
-/* The screen in which the last input event occurred.
-   command_loop_1 will select this screen before running the
+/* The frame in which the last input event occurred.
+   command_loop_1 will select this frame before running the
    command bound to an event sequence, and read_key_sequence will
    toss the existing prefix if the user starts typing at a
-   new screen.  */
-Lisp_Object Vlast_event_screen;
+   new frame.  */
+Lisp_Object Vlast_event_frame;
 
 /* The timestamp of the last input event we received from the X server.
    X Windows wants this for selection ownership.  */
@@ -494,7 +494,7 @@ echo_length ()
 
 /* Truncate the current echo message to its first LEN chars.
    This and echo_char get used by read_key_sequence when the user
-   switches screens while entering a key sequence.  */
+   switches frames while entering a key sequence.  */
 
 static void
 echo_truncate (len)
@@ -600,10 +600,10 @@ cmd_error (data)
   Vexecuting_macro = Qnil;
   echo_area_glyphs = 0;
 
-  /* If the window system or terminal screen hasn't been initialized
+  /* If the window system or terminal frame hasn't been initialized
      yet, or we're not interactive, it's best to dump this message out
      to stderr and exit.  */
-  if (! SCREEN_MESSAGE_BUF (selected_screen)
+  if (! FRAME_MESSAGE_BUF (selected_frame)
       || noninteractive)
     stream = Qexternal_debugging_output;
   else
@@ -657,9 +657,9 @@ cmd_error (data)
     }
   UNGCPRO;
 
-  /* If the window system or terminal screen hasn't been initialized
+  /* If the window system or terminal frame hasn't been initialized
      yet, or we're in -batch mode, this error should cause Emacs to exit.  */
-  if (! SCREEN_MESSAGE_BUF (selected_screen)
+  if (! FRAME_MESSAGE_BUF (selected_frame)
       || noninteractive)
     {
       Fterpri (stream);
@@ -836,11 +836,11 @@ command_loop_1 ()
 
       ++num_input_keys;
 
-#ifdef MULTI_SCREEN
-      /* Select the screen that the key sequence came from.  */
-      if (XTYPE (Vlast_event_screen) == Lisp_Screen
-          && XSCREEN (Vlast_event_screen) != selected_screen)
-        Fselect_screen (Vlast_event_screen, Qnil);
+#ifdef MULTI_FRAME
+      /* Select the frame that the key sequence came from.  */
+      if (XTYPE (Vlast_event_frame) == Lisp_Frame
+          && XFRAME (Vlast_event_frame) != selected_frame)
+        Fselect_frame (Vlast_event_frame, Qnil);
 #endif
 
       /* Now we have read a key sequence of length I,
@@ -851,7 +851,7 @@ command_loop_1 ()
 
 #if 0
 #ifdef HAVE_X_WINDOWS
-      if (SCREEN_IS_X (selected_screen))
+      if (FRAME_IS_X (selected_frame))
         {
           if (i == -1)          /* Mouse event */
             {
@@ -1159,8 +1159,8 @@ read_char (commandflag)
   if (_setjmp (getcjmp))
     {
       XSET (c, Lisp_Int, quit_char);
-#ifdef MULTI_SCREEN
-      XSET (Vlast_event_screen, Lisp_Screen, selected_screen);
+#ifdef MULTI_FRAME
+      XSET (Vlast_event_frame, Lisp_Frame, selected_frame);
 #endif
 
       goto non_reread;
@@ -1345,7 +1345,7 @@ read_char (commandflag)
 
       cancel_echoing ();
       c = read_char (0);
-      /* Remove the help from the screen */
+      /* Remove the help from the frame */
       unbind_to (count, Qnil);
       redisplay ();
       if (EQ (c, make_number (040)))
@@ -1393,7 +1393,7 @@ restore_getcjmp (temp)
 /* Set this for debugging, to have a way to get out */
 int stop_character;
 
-extern int screen_garbaged;
+extern int frame_garbaged;
 
 /* Return true iff there are any events in the queue that read-char
    would return.  If this returns false, a read-char would block.  */
@@ -1487,11 +1487,11 @@ kbd_buffer_store_event (event)
           || ((c == (0200 | quit_char)) && !meta_key))
         {
           /* If this results in a quit_char being returned to Emacs as
-             input, set last-event-screen properly.  If this doesn't
+             input, set last-event-frame properly.  If this doesn't
              get returned to Emacs as an event, the next event read
-             will set Vlast_event_screen again, so this is safe to do.  */
+             will set Vlast_event_frame again, so this is safe to do.  */
           extern SIGTYPE interrupt_signal ();
-          Vlast_event_screen = SCREEN_FOCUS_SCREEN (event->screen);
+          Vlast_event_frame = FRAME_FOCUS_FRAME (event->frame);
           last_event_timestamp = event->timestamp;
           interrupt_signal ();
           return;
@@ -1518,7 +1518,7 @@ kbd_buffer_store_event (event)
       kbd_store_ptr->kind = event->kind;
       kbd_store_ptr->code = event->code;
       kbd_store_ptr->part = event->part;
-      kbd_store_ptr->screen = event->screen;
+      kbd_store_ptr->frame = event->frame;
       kbd_store_ptr->modifiers = event->modifiers;
       kbd_store_ptr->x = event->x;
       kbd_store_ptr->y = event->y;
@@ -1610,11 +1610,11 @@ kbd_buffer_get_event ()
     {
       if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
         kbd_fetch_ptr = kbd_buffer;
-      /* Do the redirection specified by the focus_screen
+      /* Do the redirection specified by the focus_frame
          member now, before we return this event.  */
-      kbd_fetch_ptr->screen =
-        XSCREEN (SCREEN_FOCUS_SCREEN (kbd_fetch_ptr->screen));
-      XSET (Vlast_event_screen, Lisp_Screen, kbd_fetch_ptr->screen);
+      kbd_fetch_ptr->frame =
+        XFRAME (FRAME_FOCUS_FRAME (kbd_fetch_ptr->frame));
+      XSET (Vlast_event_frame, Lisp_Frame, kbd_fetch_ptr->frame);
       last_event_timestamp = kbd_fetch_ptr->timestamp;
       obj = make_lispy_event (kbd_fetch_ptr);
       kbd_fetch_ptr->kind = no_event;
@@ -1624,14 +1624,14 @@ kbd_buffer_get_event ()
     }
   else if (do_mouse_tracking && mouse_moved)
     {
-      SCREEN_PTR screen;
+      FRAME_PTR frame;
       Lisp_Object x, y;
       unsigned long time;
 
-      (*mouse_position_hook) (&screen, &x, &y, &time);
-      XSET (Vlast_event_screen, Lisp_Screen, screen);
+      (*mouse_position_hook) (&frame, &x, &y, &time);
+      XSET (Vlast_event_frame, Lisp_Frame, frame);
 
-      obj = make_lispy_movement (screen, x, y, time);
+      obj = make_lispy_movement (frame, x, y, time);
     }
   else
     /* We were promised by the above while loop that there was
@@ -1763,7 +1763,7 @@ make_lispy_event (event)
       {
         int part;
         Lisp_Object window =
-          window_from_coordinates (event->screen,
+          window_from_coordinates (event->frame,
                                    XINT (event->x), XINT (event->y),
                                    &part);
         Lisp_Object posn;
@@ -1814,7 +1814,7 @@ make_lispy_event (event)
                                  (sizeof (lispy_mouse_names)
                                   / sizeof (lispy_mouse_names[0])));
         return Fcons (event->part,
-                      Fcons (SCREEN_SELECTED_WINDOW (event->screen),
+                      Fcons (FRAME_SELECTED_WINDOW (event->frame),
                              Fcons (button,
                                     Fcons (Fcons (event->x, event->y),
                                            Fcons (make_number
@@ -1829,8 +1829,8 @@ make_lispy_event (event)
 }
 
 static Lisp_Object
-make_lispy_movement (screen, x, y, time)
-     SCREEN_PTR screen;
+make_lispy_movement (frame, x, y, time)
+     FRAME_PTR frame;
      Lisp_Object x, y;
      unsigned long time;
 {
@@ -1841,8 +1841,8 @@ make_lispy_movement (screen, x, y, time)
 
   ix = XINT (x);
   iy = XINT (y);
-  window = (screen
-            ? window_from_coordinates (screen, ix, iy, &part)
+  window = (frame
+            ? window_from_coordinates (frame, ix, iy, &part)
             : Qnil);
   if (XTYPE (window) != Lisp_Window)
     posn = Qnil;
@@ -2207,7 +2207,7 @@ read_avail_input (expected)
         {
           buf[i].kind = ascii_keystroke;
           XSET (buf[i].code, Lisp_Int, cbuf[i]);
-          buf[i].screen = selected_screen;
+          buf[i].frame = selected_frame;
         }
     }
 
@@ -2309,7 +2309,7 @@ read_char_menu_prompt (prompt, local, global)
   register Lisp_Object rest, name;
   Lisp_Object hmap;
   int nlength;
-  int width = SCREEN_WIDTH (selected_screen) - 4;
+  int width = FRAME_WIDTH (selected_frame) - 4;
   char *menu = (char *) alloca (width);
 
   /* Use local over global Menu maps */
@@ -2515,7 +2515,7 @@ follow_key (key, nmaps, current, defs, next)
    with PROMPT.  Echo starting immediately unless `prompt' is 0.
    Return the length of the key sequence stored.
 
-   If the user switches screens in the midst of a key sequence, we
+   If the user switches frames in the midst of a key sequence, we
    throw away any prefix we have read so far, and start afresh.  For
    mouse clicks, we look up the click in the keymap of the buffer
    clicked on, throwing away any prefix if it is not the same buffer
@@ -2532,7 +2532,7 @@ read_key_sequence (keybuf, bufsize, prompt)
 
   /* The buffer that the most recently read event was typed at.  This
      helps us read mouse clicks according to the buffer clicked in,
-     and notice when the mouse has moved from one screen to another.  */
+     and notice when the mouse has moved from one frame to another.  */
   struct buffer *last_event_buffer = current_buffer;
 
   /* The length of the echo buffer when we started reading, and
@@ -2639,13 +2639,13 @@ read_key_sequence (keybuf, bufsize, prompt)
           
           Vquit_flag = Qnil;
 
-#ifdef MULTI_SCREEN
+#ifdef MULTI_FRAME
           /* What buffer was this event typed/moused at?  */
           if (XTYPE (key) == Lisp_Int || XTYPE (key) == Lisp_Symbol)
             buf = (XBUFFER
                    (XWINDOW
-                    (SCREEN_SELECTED_WINDOW
-                     (XSCREEN (Vlast_event_screen)))->buffer));
+                    (FRAME_SELECTED_WINDOW
+                     (XFRAME (Vlast_event_frame)))->buffer));
           else if (EVENT_HAS_PARAMETERS (key))
             {
               Lisp_Object window = EVENT_WINDOW (key);
@@ -2664,7 +2664,7 @@ read_key_sequence (keybuf, bufsize, prompt)
           if (buf != last_event_buffer)
             {
               last_event_buffer = buf;
-              Fselect_screen (Vlast_event_screen, Qnil);
+              Fselect_frame (Vlast_event_frame, Qnil);
 
               /* Arrange to read key as the next event.  */
               keybuf[0] = key;
@@ -2753,7 +2753,7 @@ First arg PROMPT is a prompt string.  If nil, do not prompt specially.\n\
 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos\n\
 as a continuation of the previous key.\n\
 \n\
-If Emacs is running on multiple screens, switching between screens in\n\
+If Emacs is running on multiple frames, switching between frames in\n\
 the midst of a keystroke will toss any prefix typed so far.  A C-g\n\
 typed while in this function is treated like any other character, and\n\
 `quit-flag' is not set.")
@@ -2864,7 +2864,7 @@ with EVENT as arg.")
 {
   Lisp_Object tem;
   Lisp_Object mouse_cmd;
-  Lisp_Object keyseq, window, screen_part, pos, time;
+  Lisp_Object keyseq, window, frame_part, pos, time;
 
 #ifndef HAVE_X11
   Vmouse_event = event;
@@ -2879,7 +2879,7 @@ with EVENT as arg.")
   CHECK_CONS (event, 0);
   pos = Fcar (event);
   window = Fcar (Fcdr (event));
-  screen_part = Fcar (Fcdr (Fcdr (event)));
+  frame_part = Fcar (Fcdr (Fcdr (event)));
   keyseq = Fcar (Fcdr (Fcdr (Fcdr (event))));
   time = Fcar (Fcdr (Fcdr (Fcdr (Fcdr (event)))));
   CHECK_STRING (keyseq, 0);
@@ -2921,14 +2921,14 @@ with EVENT as arg.")
     }
   else
     {
-      SCREEN_PTR s = XSCREEN (WINDOW_SCREEN (XWINDOW (window)));
+      FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
 
 #ifndef HAVE_X11
-      Vmouse_window = s->selected_window;
+      Vmouse_window = f->selected_window;
 #endif  /* HAVE_X11 */
       /* It's defined; call the definition.  */
       Vprefix_arg = Qnil;
-      if (!NILP (screen_part))
+      if (!NILP (frame_part))
         {
           /* For a scroll-bar click, set the prefix arg
              to the number of lines down from the top the click was.
@@ -2943,7 +2943,7 @@ with EVENT as arg.")
 
           if (XINT (length) != 0)
             XSET (Vprefix_arg, Lisp_Int,
-                  (SCREEN_HEIGHT (s) * (XINT (position) + XINT (offset))
+                  (FRAME_HEIGHT (f) * (XINT (position) + XINT (offset))
                    / (XINT (length) + 2 * XINT (offset))));
         }
       Fcommand_execute (mouse_cmd, Qnil);
@@ -3167,7 +3167,7 @@ On such systems, Emacs will start a subshell and wait for it to exit.")
       if (!EQ (tem, Qnil)) return Qnil;
     }
 
-  get_screen_size (&old_width, &old_height);
+  get_frame_size (&old_width, &old_height);
   reset_sys_modes ();
   /* sys_suspend can get an error if it tries to fork a subshell
      and the system resources aren't available for that.  */
@@ -3179,9 +3179,9 @@ On such systems, Emacs will start a subshell and wait for it to exit.")
   /* Check if terminal/window size has changed.
      Note that this is not useful when we are running directly
      with a window system; but suspend should be disabled in that case.  */
-  get_screen_size (&width, &height);
+  get_frame_size (&width, &height);
   if (width != old_width || height != old_height)
-    change_screen_size (height, width, 0);
+    change_frame_size (height, width, 0);
 
   /* Call value of suspend-resume-hook
      if it is bound and value is non-nil.  */
@@ -3284,7 +3284,7 @@ interrupt_signal ()
 
   cancel_echoing ();
 
-  if (!NILP (Vquit_flag) && SCREEN_IS_TERMCAP (selected_screen))
+  if (!NILP (Vquit_flag) && FRAME_IS_TERMCAP (selected_frame))
     {
       fflush (stdout);
       reset_sys_modes ();
@@ -3618,9 +3618,9 @@ Polling is automatically disabled in all other cases.");
     "*Number of complete keys read from the keyboard so far.");
   num_input_keys = 0;
 
-  DEFVAR_LISP ("last-event-screen", &Vlast_event_screen,
-    "*The screen in which the most recently read event occurred.");
-  Vlast_event_screen = Qnil;
+  DEFVAR_LISP ("last-event-frame", &Vlast_event_frame,
+    "*The frame in which the most recently read event occurred.");
+  Vlast_event_frame = Qnil;
 
   DEFVAR_LISP ("help-char", &help_char,
     "Character to recognize as meaning Help.\n\
@@ -3656,13 +3656,13 @@ See the variable `mouse-event' for the format of this list.");
                "Function to call when mouse leaves window.  No arguments.");
   Vmouse_left_hook = Qnil;
 
-  DEFVAR_LISP ("map-screen-hook", &Vmap_screen_hook,
-               "Function to call when screen is mapped.  No arguments.");
-  Vmap_screen_hook = Qnil;
+  DEFVAR_LISP ("map-frame-hook", &Vmap_frame_hook,
+               "Function to call when frame is mapped.  No arguments.");
+  Vmap_frame_hook = Qnil;
 
-  DEFVAR_LISP ("unmap-screen-hook", &Vunmap_screen_hook,
-               "Function to call when screen is unmapped.  No arguments.");
-  Vunmap_screen_hook = Qnil;
+  DEFVAR_LISP ("unmap-frame-hook", &Vunmap_frame_hook,
+               "Function to call when frame is unmapped.  No arguments.");
+  Vunmap_frame_hook = Qnil;
 
   DEFVAR_LISP ("mouse-motion-handler", &Vmouse_motion_handler,
                "Handler for motion events.  No arguments.");
diff --git a/src/lisp.h b/src/lisp.h
index d981fd74bc5..070ad977f0a 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -86,9 +86,9 @@ enum Lisp_Type
        XOBJFWD(obj) points to the Lisp_Object variable. */
     Lisp_Objfwd,
 
-    /* Pointer to a vector-like object describing a display screen
+    /* Pointer to a vector-like object describing a display frame
        on which Emacs can display a window hierarchy.  */
-    Lisp_Screen,
+    Lisp_Frame,
 
     /* Used when a FILE * value needs to be passed
        in an argument of type Lisp_Object.
@@ -840,7 +840,7 @@ extern Lisp_Object Qcdr;
 extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
 #endif /* LISP_FLOAT_TYPE */
 
-extern Lisp_Object Qscreenp;
+extern Lisp_Object Qframep;
 
 extern Lisp_Object Feq (), Fnull (), Flistp (), Fconsp (), Fatom (), Fnlistp ();
 extern Lisp_Object Fintegerp (), Fnatnump (), Fsymbolp ();
@@ -1040,35 +1040,35 @@ extern Lisp_Object Fset_window_configuration (), Fcurrent_window_configuration (
 extern Lisp_Object Fcoordinates_in_window_p ();
 extern Lisp_Object Fwindow_at ();
 
-/* defined in screen.c */
-extern Lisp_Object Fscreenp ();
-extern Lisp_Object Fselect_screen ();
-extern Lisp_Object Ffocus_screen ();
-extern Lisp_Object Funfocus_screen ();
-extern Lisp_Object Fselected_screen ();
-extern Lisp_Object Fwindow_screen ();
-extern Lisp_Object Fscreen_root_window ();
-extern Lisp_Object Fscreen_selected_window ();
-extern Lisp_Object Fscreen_list ();
-extern Lisp_Object Fnext_screen ();
-extern Lisp_Object Fdelete_screen ();
+/* defined in frame.c */
+extern Lisp_Object Fframep ();
+extern Lisp_Object Fselect_frame ();
+extern Lisp_Object Ffocus_frame ();
+extern Lisp_Object Funfocus_frame ();
+extern Lisp_Object Fselected_frame ();
+extern Lisp_Object Fwindow_frame ();
+extern Lisp_Object Fframe_root_window ();
+extern Lisp_Object Fframe_selected_window ();
+extern Lisp_Object Fframe_list ();
+extern Lisp_Object Fnext_frame ();
+extern Lisp_Object Fdelete_frame ();
 extern Lisp_Object Fread_mouse_position ();
 extern Lisp_Object Fset_mouse_position ();
-extern Lisp_Object Fmake_screen_visible ();
-extern Lisp_Object Fmake_screen_invisible ();
-extern Lisp_Object Ficonify_screen ();
-extern Lisp_Object Fdeiconify_screen ();
-extern Lisp_Object Fscreen_visible_p ();
-extern Lisp_Object Fvisible_screen_list ();
-extern Lisp_Object Fscreen_parameters ();
-extern Lisp_Object Fmodify_screen_parameters ();
-extern Lisp_Object Fscreen_pixel_size ();
-extern Lisp_Object Fscreen_height ();
-extern Lisp_Object Fscreen_width ();
-extern Lisp_Object Fset_screen_height ();
-extern Lisp_Object Fset_screen_width ();
-extern Lisp_Object Fset_screen_size ();
-extern Lisp_Object Fset_screen_position ();
+extern Lisp_Object Fmake_frame_visible ();
+extern Lisp_Object Fmake_frame_invisible ();
+extern Lisp_Object Ficonify_frame ();
+extern Lisp_Object Fdeiconify_frame ();
+extern Lisp_Object Fframe_visible_p ();
+extern Lisp_Object Fvisible_frame_list ();
+extern Lisp_Object Fframe_parameters ();
+extern Lisp_Object Fmodify_frame_parameters ();
+extern Lisp_Object Fframe_pixel_size ();
+extern Lisp_Object Fframe_height ();
+extern Lisp_Object Fframe_width ();
+extern Lisp_Object Fset_frame_height ();
+extern Lisp_Object Fset_frame_width ();
+extern Lisp_Object Fset_frame_size ();
+extern Lisp_Object Fset_frame_position ();
 #ifndef HAVE_X11
 extern Lisp_Object Frubber_band_rectangle ();
 #endif  /* HAVE_X11 */
diff --git a/src/minibuf.c b/src/minibuf.c
index 97cf6d131e7..08abe94e789 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -23,7 +23,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "commands.h"
 #include "buffer.h"
 #include "dispextern.h"
-#include "screen.h"
+#include "frame.h"
 #include "window.h"
 #include "syntax.h"
 
@@ -91,7 +91,7 @@ read_minibuf (map, initial, prompt, backup_n, expflag)
 {
   register Lisp_Object val;
   int count = specpdl_ptr - specpdl;
-  Lisp_Object mini_screen = WINDOW_SCREEN (XWINDOW (minibuf_window));
+  Lisp_Object mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
   struct gcpro gcpro1, gcpro2;
 
   if (XTYPE (prompt) != Lisp_String)
@@ -105,7 +105,7 @@ read_minibuf (map, initial, prompt, backup_n, expflag)
       && minibuf_level > 0
       && (EQ (selected_window, minibuf_window)))
 #if 0
-          || selected_screen != XSCREEN (WINDOW_SCREEN (XWINDOW (minibuf_window)))
+          || selected_frame != XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)))
 #endif
     error ("Command attempted to use minibuffer while in minibuffer");
 
@@ -127,12 +127,12 @@ read_minibuf (map, initial, prompt, backup_n, expflag)
   record_unwind_protect (Fset_window_configuration,
                          Fcurrent_window_configuration (Qnil));
 
-  /* If the minibuffer window is on a different screen, save that
-     screen's configuration too.  */
-  if (XSCREEN (mini_screen) != selected_screen)
+  /* If the minibuffer window is on a different frame, save that
+     frame's configuration too.  */
+  if (XFRAME (mini_frame) != selected_frame)
     {
       record_unwind_protect (Fset_window_configuration,
-                             Fcurrent_window_configuration (mini_screen));
+                             Fcurrent_window_configuration (mini_frame));
     }
 
   val = current_buffer->directory;
@@ -141,17 +141,17 @@ read_minibuf (map, initial, prompt, backup_n, expflag)
   Fmake_local_variable (Qprint_escape_newlines);
   print_escape_newlines = 1;
 
-#ifdef MULTI_SCREEN
-  /* If the minibuffer window is on another screen, shift this screen's
+#ifdef MULTI_FRAME
+  /* If the minibuffer window is on another frame, shift this frame's
      focus to that window, and arrange to put it back later.  */
-  if (XSCREEN (WINDOW_SCREEN (XWINDOW (minibuf_window)))
-      != selected_screen)
+  if (XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)))
+      != selected_frame)
     {
       record_unwind_protect (read_minibuf_unwind,
-                             Fcons (Fselected_screen (),
-                                    SCREEN_FOCUS_SCREEN (selected_screen)));
+                             Fcons (Fselected_frame (),
+                                    FRAME_FOCUS_FRAME (selected_frame)));
 
-      Fredirect_screen_focus (Fselected_screen (), mini_screen);
+      Fredirect_frame_focus (Fselected_frame (), mini_frame);
     }
   else
     record_unwind_protect (read_minibuf_unwind, Qnil);
@@ -186,18 +186,18 @@ read_minibuf (map, initial, prompt, backup_n, expflag)
 
   /* If cursor is on the minibuffer line,
      show the user we have exited by putting it in column 0.  */
-  if ((SCREEN_CURSOR_Y (selected_screen)
+  if ((FRAME_CURSOR_Y (selected_frame)
        >= XFASTINT (XWINDOW (minibuf_window)->top))
       && !noninteractive)
     {
-      SCREEN_CURSOR_X (selected_screen) = 0;
-      update_screen (selected_screen, 1, 1);
+      FRAME_CURSOR_X (selected_frame) = 0;
+      update_frame (selected_frame, 1, 1);
     }
 
   /* Make minibuffer contents into a string */
   val = make_buffer_string (1, Z);
   bcopy (GAP_END_ADDR, XSTRING (val)->data + GPT - BEG, Z - GPT);
-  unbind_to (count, Qnil);      /* The appropriate screen will get selected
+  unbind_to (count, Qnil);      /* The appropriate frame will get selected
                                    in set-window-configuration.  */
 
   UNGCPRO;
@@ -271,10 +271,10 @@ read_minibuf_unwind (data)
   Vhelp_form = minibuf_save_vector[minibuf_level].help_form;
   Vcurrent_prefix_arg = minibuf_save_vector[minibuf_level].current_prefix_arg;
 
-#ifdef MULTI_SCREEN
-  /* Redirect the focus of the screen that called the minibuffer.  */
+#ifdef MULTI_FRAME
+  /* Redirect the focus of the frame that called the minibuffer.  */
   if (CONSP (data))
-    Fredirect_screen_focus (XCONS (data)->car, XCONS (data)->cdr);
+    Fredirect_frame_focus (XCONS (data)->car, XCONS (data)->cdr);
 #endif
 }
 
diff --git a/src/process.c b/src/process.c
index 2265c2c34db..e950a7b4395 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1723,11 +1723,11 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
       if (! XINT (read_kbd))
         FD_CLR (0, &Available);
 
-      /* If screen size has changed or the window is newly mapped,
+      /* If frame size has changed or the window is newly mapped,
          redisplay now, before we start to wait.  There is a race
          condition here; if a SIGIO arrives between now and the select
-         and indicates that a screen is trashed, we lose.  */
-      if (screen_garbaged)
+         and indicates that a frame is trashed, we lose.  */
+      if (frame_garbaged)
         redisplay_preserve_echo_area ();
 
       if (XINT (read_kbd) && detect_input_pending ())
@@ -2898,7 +2898,7 @@ effect when `start-process' is called.");
 #include "systime.h"
 #include "termopts.h"
 
-extern int screen_garbaged;
+extern int frame_garbaged;
 
 
 /* As described above, except assuming that there are no subprocesses:
@@ -2981,9 +2981,9 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
       if (XINT (read_kbd) < 0)
         set_waiting_for_input (&timeout);
 
-      /* If a screen has been newly mapped and needs updating,
+      /* If a frame has been newly mapped and needs updating,
          reprocess its display stuff.  */
-      if (screen_garbaged)
+      if (frame_garbaged)
         redisplay_preserve_echo_area ();
 
       if (XINT (read_kbd) && detect_input_pending ())
diff --git a/src/term.c b/src/term.c
index 3663c44ff91..ede02179c8b 100644
--- a/src/term.c
+++ b/src/term.c
@@ -26,7 +26,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "cm.h"
 #undef NULL
 #include "lisp.h"
-#include "screen.h"
+#include "frame.h"
 #include "disptab.h"
 #include "termhooks.h"
 #include "keyboard.h"
@@ -34,10 +34,10 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define max(a, b) ((a) > (b) ? (a) : (b))
 #define min(a, b) ((a) < (b) ? (a) : (b))
 
-#define OUTPUT(a) tputs (a, SCREEN_HEIGHT (selected_screen) - curY, cmputc)
+#define OUTPUT(a) tputs (a, FRAME_HEIGHT (selected_frame) - curY, cmputc)
 #define OUTPUT1(a) tputs (a, 1, cmputc)
 #define OUTPUTL(a, lines) tputs (a, lines, cmputc)
-#define OUTPUT_IF(a) { if (a) tputs (a, SCREEN_HEIGHT (selected_screen) - curY, cmputc); }
+#define OUTPUT_IF(a) { if (a) tputs (a, FRAME_HEIGHT (selected_frame) - curY, cmputc); }
 #define OUTPUT1_IF(a) { if (a) tputs (a, 1, cmputc); }
 
 /* Terminal charateristics that higher levels want to look at.
@@ -52,14 +52,14 @@ int line_ins_del_ok;		/* Terminal can insert and delete lines */
 int char_ins_del_ok;            /* Terminal can insert and delete chars */
 int scroll_region_ok;           /* Terminal supports setting the
                                    scroll window */
-int memory_below_screen;        /* Terminal remembers lines
+int memory_below_frame;         /* Terminal remembers lines
                                    scrolled off bottom */
 int fast_clear_end_of_line;     /* Terminal has a `ce' string */
 
 int dont_calculate_costs;       /* Nonzero means don't bother computing */
                                 /* various cost tables; we won't use them.  */
 
-/* Nonzero means no need to redraw the entire screen on resuming
+/* Nonzero means no need to redraw the entire frame on resuming
    a suspended Emacs.  This is useful on terminals with multiple pages,
    where one page is used for Emacs and another for all else. */
 int no_redraw_on_reenter;
@@ -71,7 +71,7 @@ int (*cursor_to_hook) ();
 int (*raw_cursor_to_hook) ();
 
 int (*clear_to_end_hook) ();
-int (*clear_screen_hook) ();
+int (*clear_frame_hook) ();
 int (*clear_end_of_line_hook) ();
 
 int (*ins_del_lines_hook) ();
@@ -95,17 +95,17 @@ int (*read_socket_hook) ();
 
 /* Return the current position of the mouse.  This should clear
    mouse_moved until the next motion event arrives.  */
-void (*mouse_position_hook) ( /* SCREEN_PTR *s,
+void (*mouse_position_hook) ( /* FRAME_PTR *f,
                                         Lisp_Object *x,
                                         Lisp_Object *y,
                                         unsigned long *time */ );
 
-/* When reading from a minibuffer in a different screen, Emacs wants
-   to shift the highlight from the selected screen to the minibuffer's
-   screen; under X, this means it lies about where the focus is.
+/* When reading from a minibuffer in a different frame, Emacs wants
+   to shift the highlight from the selected frame to the minibuffer's
+   frame; under X, this means it lies about where the focus is.
    This hook tells the window system code to re-decide where to put
    the highlight.  */
-void (*screen_rehighlight_hook) ( /* SCREEN_PTR s */ );
+void (*frame_rehighlight_hook) ( /* FRAME_PTR f */ );
 
 /* Strings, numbers and flags taken from the termcap entry.  */
 
@@ -114,7 +114,7 @@ char *TS_ins_multi_lines;	/* "AL" (one parameter, # lines to insert) */
 char *TS_bell;                  /* "bl" */
 char *TS_clr_to_bottom;         /* "cd" */
 char *TS_clr_line;              /* "ce", clear to end of line */
-char *TS_clr_screen;            /* "cl" */
+char *TS_clr_frame;             /* "cl" */
 char *TS_set_scroll_region;     /* "cs" (2 params, first line and last line) */
 char *TS_set_scroll_region_1;   /* "cS" (4 params: total lines,
                                    lines above scroll region, lines below it,
@@ -186,24 +186,24 @@ int insert_mode;			/* Nonzero when in insert mode.  */
 int standout_mode;                      /* Nonzero when in standout mode.  */
 
 /* Size of window specified by higher levels.
-   This is the number of lines, from the top of screen downwards,
+   This is the number of lines, from the top of frame downwards,
    which can participate in insert-line/delete-line operations.
 
-   Effectively it excludes the bottom screen_height - specified_window_size
+   Effectively it excludes the bottom frame_height - specified_window_size
    lines from those operations.  */
 
 int specified_window;
 
-/* Screen currently being redisplayed; 0 if not currently redisplaying.
+/* Frame currently being redisplayed; 0 if not currently redisplaying.
    (Direct output does not count).  */
 
-SCREEN_PTR updating_screen;
+FRAME_PTR updating_frame;
 
 char *tparam ();
 
 ring_bell ()
 {
-  if (! SCREEN_IS_TERMCAP (selected_screen))
+  if (! FRAME_IS_TERMCAP (selected_frame))
     {
       (*ring_bell_hook) ();
       return;
@@ -213,7 +213,7 @@ ring_bell ()
 
 set_terminal_modes ()
 {
-  if (! SCREEN_IS_TERMCAP (selected_screen))
+  if (! FRAME_IS_TERMCAP (selected_frame))
     {
       (*set_terminal_modes_hook) ();
       return;
@@ -226,7 +226,7 @@ set_terminal_modes ()
 
 reset_terminal_modes ()
 {
-  if (! SCREEN_IS_TERMCAP (selected_screen))
+  if (! FRAME_IS_TERMCAP (selected_frame))
     {
       (*reset_terminal_modes_hook) ();
       return;
@@ -239,44 +239,44 @@ reset_terminal_modes ()
   OUTPUT_IF (TS_end_termcap_modes);
   /* Output raw CR so kernel can track the cursor hpos.  */
   /* But on magic-cookie terminals this can erase an end-standout marker and
-     cause the rest of the screen to be in standout, so move down first.  */
+     cause the rest of the frame to be in standout, so move down first.  */
   if (TN_standout_width >= 0)
     cmputc ('\n');
   cmputc ('\r');
 }
 
-update_begin (s)
-     SCREEN_PTR s;
+update_begin (f)
+     FRAME_PTR f;
 {
-  updating_screen = s;
-  if (! SCREEN_IS_TERMCAP (updating_screen))
-    (*update_begin_hook) (s);
+  updating_frame = f;
+  if (! FRAME_IS_TERMCAP (updating_frame))
+    (*update_begin_hook) (f);
 }
 
-update_end (s)
-     SCREEN_PTR s;
+update_end (f)
+     FRAME_PTR f;
 {
-  if (! SCREEN_IS_TERMCAP (updating_screen))
+  if (! FRAME_IS_TERMCAP (updating_frame))
     {
-      (*update_end_hook) (s);
-      updating_screen = 0;
+      (*update_end_hook) (f);
+      updating_frame = 0;
       return;
     }
   turn_off_insert ();
   background_highlight ();
   standout_requested = 0;
-  updating_screen = 0;
+  updating_frame = 0;
 }
 
 set_terminal_window (size)
      int size;
 {
-  if (! SCREEN_IS_TERMCAP (updating_screen))
+  if (! FRAME_IS_TERMCAP (updating_frame))
     {
       (*set_terminal_window_hook) (size);
       return;
     }
-  specified_window = size ? size : SCREEN_HEIGHT (selected_screen);
+  specified_window = size ? size : FRAME_HEIGHT (selected_frame);
   if (!scroll_region_ok)
     return;
   set_scroll_region (0, specified_window);
@@ -293,13 +293,13 @@ set_scroll_region (start, stop)
   else if (TS_set_scroll_region_1)
     {
       buf = tparam (TS_set_scroll_region_1, 0, 0,
-                    SCREEN_HEIGHT (selected_screen), start,
-                    SCREEN_HEIGHT (selected_screen) - stop,
-                    SCREEN_HEIGHT (selected_screen));
+                    FRAME_HEIGHT (selected_frame), start,
+                    FRAME_HEIGHT (selected_frame) - stop,
+                    FRAME_HEIGHT (selected_frame));
     }
   else
     {
-      buf = tparam (TS_set_window, 0, 0, start, 0, stop, SCREEN_WIDTH (selected_screen));
+      buf = tparam (TS_set_window, 0, 0, start, 0, stop, FRAME_WIDTH (selected_frame));
     }
   OUTPUT (buf);
   free (buf);
@@ -376,7 +376,7 @@ highlight_if_desired ()
 
 /* Handle standout mode for terminals in which TN_standout_width >= 0.
    On these terminals, standout is controlled by markers that
-   live inside the screen memory.  TN_standout_width is the width
+   live inside the terminal's memory.  TN_standout_width is the width
    that the marker occupies in memory.  Standout runs from the marker
    to the end of the line on some terminals, or to the next
    turn-off-standout marker (TS_end_standout_mode) string
@@ -406,7 +406,7 @@ reassert_line_highlight (highlight, vpos)
      int highlight;
      int vpos;
 {
-  if (! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
+  if (! FRAME_IS_TERMCAP ((updating_frame ? updating_frame : selected_frame)))
     {
       (*reassert_line_highlight_hook) (highlight, vpos);
       return;
@@ -427,7 +427,7 @@ change_line_highlight (new_highlight, vpos, first_unused_hpos)
      int new_highlight, vpos, first_unused_hpos;
 {
   standout_requested = new_highlight;
-  if (! SCREEN_IS_TERMCAP (updating_screen))
+  if (! FRAME_IS_TERMCAP (updating_frame))
     {
       (*change_line_highlight_hook) (new_highlight, vpos, first_unused_hpos);
       return;
@@ -444,7 +444,7 @@ change_line_highlight (new_highlight, vpos, first_unused_hpos)
       /* On Teleray, make sure to erase the SO marker.  */
       if (TF_teleray)
         {
-          cmgoto (curY - 1, SCREEN_WIDTH (selected_screen) - 4);
+          cmgoto (curY - 1, FRAME_WIDTH (selected_frame) - 4);
           OUTPUT ("\033S");
           curY++;               /* ESC S moves to next line where the TS_standout_mode was */
           curX = 0;
@@ -462,9 +462,9 @@ change_line_highlight (new_highlight, vpos, first_unused_hpos)
 cursor_to (row, col)
      int row, col;
 {
-  if (! SCREEN_IS_TERMCAP ((updating_screen
-                            ? updating_screen
-                            : selected_screen))
+  if (! FRAME_IS_TERMCAP ((updating_frame
+                            ? updating_frame
+                            : selected_frame))
       && cursor_to_hook)
     {
       (*cursor_to_hook) (row, col);
@@ -486,7 +486,7 @@ cursor_to (row, col)
 raw_cursor_to (row, col)
      int row, col;
 {
-  if (! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
+  if (! FRAME_IS_TERMCAP ((updating_frame ? updating_frame : selected_frame)))
     {
       (*raw_cursor_to_hook) (row, col);
       return;
@@ -502,12 +502,12 @@ raw_cursor_to (row, col)
 
 /* Erase operations */
 
-/* clear from cursor to end of screen */
+/* clear from cursor to end of frame */
 clear_to_end ()
 {
   register int i;
 
-  if (clear_to_end_hook && SCREEN_IS_TERMCAP (updating_screen))
+  if (clear_to_end_hook && FRAME_IS_TERMCAP (updating_frame))
     {
       (*clear_to_end_hook) ();
       return;
@@ -516,33 +516,33 @@ clear_to_end ()
     {
       background_highlight ();
       OUTPUT (TS_clr_to_bottom);
-      bzero (chars_wasted + curY, SCREEN_HEIGHT (selected_screen) - curY);
+      bzero (chars_wasted + curY, FRAME_HEIGHT (selected_frame) - curY);
     }
   else
     {
-      for (i = curY; i < SCREEN_HEIGHT (selected_screen); i++)
+      for (i = curY; i < FRAME_HEIGHT (selected_frame); i++)
         {
           cursor_to (i, 0);
-          clear_end_of_line_raw (SCREEN_WIDTH (selected_screen));
+          clear_end_of_line_raw (FRAME_WIDTH (selected_frame));
         }
     }
 }
 
-/* Clear entire screen */
+/* Clear entire frame */
 
-clear_screen ()
+clear_frame ()
 {
-  if (clear_screen_hook
-      && ! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
+  if (clear_frame_hook
+      && ! FRAME_IS_TERMCAP ((updating_frame ? updating_frame : selected_frame)))
     {
-      (*clear_screen_hook) ();
+      (*clear_frame_hook) ();
       return;
     }
-  if (TS_clr_screen)
+  if (TS_clr_frame)
     {
       background_highlight ();
-      OUTPUT (TS_clr_screen);
-      bzero (chars_wasted, SCREEN_HEIGHT (selected_screen));
+      OUTPUT (TS_clr_frame);
+      bzero (chars_wasted, FRAME_HEIGHT (selected_frame));
       cmat (0, 0);
     }
   else
@@ -563,7 +563,7 @@ clear_end_of_line (first_unused_hpos)
      int first_unused_hpos;
 {
   static GLYPH buf[1] = {SPACEGLYPH};
-  if (SCREEN_IS_TERMCAP (selected_screen)
+  if (FRAME_IS_TERMCAP (selected_frame)
       && TN_standout_width == 0 && curX == 0 && chars_wasted[curY] != 0)
     write_glyphs (buf, 1);
   clear_end_of_line_raw (first_unused_hpos);
@@ -581,9 +581,9 @@ clear_end_of_line_raw (first_unused_hpos)
   register int i;
 
   if (clear_end_of_line_hook
-      && ! SCREEN_IS_TERMCAP ((updating_screen
-                               ? updating_screen
-                               : selected_screen)))
+      && ! FRAME_IS_TERMCAP ((updating_frame
+                               ? updating_frame
+                               : selected_frame)))
     {
       (*clear_end_of_line_hook) (first_unused_hpos);
       return;
@@ -605,8 +605,8 @@ clear_end_of_line_raw (first_unused_hpos)
       turn_off_insert ();
 
       /* Do not write in last row last col with Autowrap on. */
-      if (AutoWrap && curY == SCREEN_HEIGHT (selected_screen) - 1
-          && first_unused_hpos == SCREEN_WIDTH (selected_screen))
+      if (AutoWrap && curY == FRAME_HEIGHT (selected_frame) - 1
+          && first_unused_hpos == FRAME_WIDTH (selected_frame))
         first_unused_hpos--;
 
       for (i = curX; i < first_unused_hpos; i++)
@@ -629,7 +629,7 @@ write_glyphs (string, len)
   register Lisp_Object *tbase = GLYPH_TABLE_BASE;
 
   if (write_glyphs_hook
-      && ! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
+      && ! FRAME_IS_TERMCAP ((updating_frame ? updating_frame : selected_frame)))
     {
       (*write_glyphs_hook) (string, len);
       return;
@@ -639,12 +639,12 @@ write_glyphs (string, len)
   turn_off_insert ();
 
   /* Don't dare write in last column of bottom line, if AutoWrap,
-     since that would scroll the whole screen on some terminals.  */
+     since that would scroll the whole frame on some terminals.  */
 
   if (AutoWrap
-      && curY + 1 == SCREEN_HEIGHT (selected_screen)
+      && curY + 1 == FRAME_HEIGHT (selected_frame)
       && (curX + len - (chars_wasted[curY] & 077)
-          == SCREEN_WIDTH (selected_screen)))
+          == FRAME_WIDTH (selected_frame)))
     len --;
 
   cmplus (len);
@@ -696,7 +696,7 @@ insert_glyphs (start, len)
   register int tlen = GLYPH_TABLE_LENGTH;
   register Lisp_Object *tbase = GLYPH_TABLE_BASE;
 
-  if (insert_glyphs_hook && ! SCREEN_IS_TERMCAP (updating_screen))
+  if (insert_glyphs_hook && ! FRAME_IS_TERMCAP (updating_frame))
     {
       (*insert_glyphs_hook) (start, len);
       return;
@@ -751,7 +751,7 @@ delete_glyphs (n)
   char *buf;
   register int i;
 
-  if (delete_glyphs_hook && ! SCREEN_IS_TERMCAP (updating_screen))
+  if (delete_glyphs_hook && ! FRAME_IS_TERMCAP (updating_frame))
     {
       (*delete_glyphs_hook) (n);
       return;
@@ -792,7 +792,7 @@ ins_del_lines (vpos, n)
   register int i = n > 0 ? n : -n;
   register char *buf;
 
-  if (ins_del_lines_hook && ! SCREEN_IS_TERMCAP (updating_screen))
+  if (ins_del_lines_hook && ! FRAME_IS_TERMCAP (updating_frame))
     {
       (*ins_del_lines_hook) (vpos, n);
       return;
@@ -807,7 +807,7 @@ ins_del_lines (vpos, n)
      as there will be a matching inslines later that will flush them. */
   if (scroll_region_ok && vpos + i >= specified_window)
     return;
-  if (!memory_below_screen && vpos + i >= SCREEN_HEIGHT (selected_screen))
+  if (!memory_below_frame && vpos + i >= FRAME_HEIGHT (selected_frame))
     return;
 
   if (multi)
@@ -845,7 +845,7 @@ ins_del_lines (vpos, n)
       register lower_limit
         = (scroll_region_ok
            ? specified_window
-           : SCREEN_HEIGHT (selected_screen));
+           : FRAME_HEIGHT (selected_frame));
 
       if (n < 0)
         {
@@ -861,9 +861,9 @@ ins_del_lines (vpos, n)
           bzero (&chars_wasted[vpos], n);
         }
     }
-  if (!scroll_region_ok && memory_below_screen && n < 0)
+  if (!scroll_region_ok && memory_below_frame && n < 0)
     {
-      cursor_to (SCREEN_HEIGHT (selected_screen) + n, 0);
+      cursor_to (FRAME_HEIGHT (selected_frame) + n, 0);
       clear_to_end ();
     }
 }
@@ -916,13 +916,13 @@ per_line_cost (str)
 
 int *char_ins_del_vector;
 
-#define char_ins_del_cost(s) (&char_ins_del_vector[SCREEN_WIDTH ((s))])
+#define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH ((f))])
 #endif
 
 /* ARGSUSED */
 static void
-calculate_ins_del_char_costs (screen)
-     SCREEN_PTR screen;
+calculate_ins_del_char_costs (frame)
+     FRAME_PTR frame;
 {
   int ins_startup_cost, del_startup_cost;
   int ins_cost_per_char, del_cost_per_char;
@@ -968,27 +968,27 @@ calculate_ins_del_char_costs (screen)
     }
 
   /* Delete costs are at negative offsets */
-  p = &char_ins_del_cost (screen)[0];
-  for (i = SCREEN_WIDTH (selected_screen); --i >= 0;)
+  p = &char_ins_del_cost (frame)[0];
+  for (i = FRAME_WIDTH (selected_frame); --i >= 0;)
     *--p = (del_startup_cost += del_cost_per_char);
 
   /* Doing nothing is free */
-  p = &char_ins_del_cost (screen)[0];
+  p = &char_ins_del_cost (frame)[0];
   *p++ = 0;
 
   /* Insert costs are at positive offsets */
-  for (i = SCREEN_WIDTH (screen); --i >= 0;)
+  for (i = FRAME_WIDTH (frame); --i >= 0;)
     *p++ = (ins_startup_cost += ins_cost_per_char);
 }
 
 #ifdef HAVE_X_WINDOWS
-extern int x_screen_planes;
+extern int x_frame_planes;
 #endif
 
-calculate_costs (screen)
-     SCREEN_PTR screen;
+calculate_costs (frame)
+     FRAME_PTR frame;
 {
-  register char *s = TS_set_scroll_region ?
+  register char *f = TS_set_scroll_region ?
                        TS_set_scroll_region
                      : TS_set_scroll_region_1;
 
@@ -996,16 +996,16 @@ calculate_costs (screen)
     return;
 
 #ifdef HAVE_X_WINDOWS
-  if (SCREEN_IS_X (screen))
+  if (FRAME_IS_X (frame))
     {
-      do_line_insertion_deletion_costs (screen, 0, ".5*", 0, ".5*",
-                                        0, 0, x_screen_planes);
+      do_line_insertion_deletion_costs (frame, 0, ".5*", 0, ".5*",
+                                        0, 0, x_frame_planes);
       return;
     }
 #endif
 
   /* These variables are only used for terminal stuff.  They are allocated
-     once for the terminal screen of X-windows emacs, but not used afterwards.
+     once for the terminal frame of X-windows emacs, but not used afterwards.
 
      char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
      X turns off char_ins_del_ok.
@@ -1014,48 +1014,48 @@ calculate_costs (screen)
      the term hook isn't called. */
 
   if (chars_wasted != 0)
-    chars_wasted = (char *) xrealloc (chars_wasted, SCREEN_HEIGHT (screen));
+    chars_wasted = (char *) xrealloc (chars_wasted, FRAME_HEIGHT (frame));
   else
-    chars_wasted = (char *) xmalloc (SCREEN_HEIGHT (screen));
+    chars_wasted = (char *) xmalloc (FRAME_HEIGHT (frame));
 
   if (copybuf != 0)
-    copybuf = (char *) xrealloc (copybuf, SCREEN_HEIGHT (screen));
+    copybuf = (char *) xrealloc (copybuf, FRAME_HEIGHT (frame));
   else
-    copybuf = (char *) xmalloc (SCREEN_HEIGHT (screen));
+    copybuf = (char *) xmalloc (FRAME_HEIGHT (frame));
 
   if (char_ins_del_vector != 0)
     char_ins_del_vector
       = (int *) xrealloc (char_ins_del_vector,
                           (sizeof (int)
-                           + 2 * SCREEN_WIDTH (screen) * sizeof (int)));
+                           + 2 * FRAME_WIDTH (frame) * sizeof (int)));
   else
     char_ins_del_vector
       = (int *) xmalloc (sizeof (int)
-                         + 2 * SCREEN_WIDTH (screen) * sizeof (int));
+                         + 2 * FRAME_WIDTH (frame) * sizeof (int));
 
-  bzero (chars_wasted, SCREEN_HEIGHT (screen));
-  bzero (copybuf, SCREEN_HEIGHT (screen));
+  bzero (chars_wasted, FRAME_HEIGHT (frame));
+  bzero (copybuf, FRAME_HEIGHT (frame));
   bzero (char_ins_del_vector, (sizeof (int)
-                               + 2 * SCREEN_WIDTH (screen) * sizeof (int)));
+                               + 2 * FRAME_WIDTH (frame) * sizeof (int)));
 
-  if (s && (!TS_ins_line && !TS_del_line))
-    do_line_insertion_deletion_costs (screen,
+  if (f && (!TS_ins_line && !TS_del_line))
+    do_line_insertion_deletion_costs (frame,
                                       TS_rev_scroll, TS_ins_multi_lines,
                                       TS_fwd_scroll, TS_del_multi_lines,
-                                      s, s, 1);
+                                      f, f, 1);
   else
-    do_line_insertion_deletion_costs (screen,
+    do_line_insertion_deletion_costs (frame,
                                       TS_ins_line, TS_ins_multi_lines,
                                       TS_del_line, TS_del_multi_lines,
                                       0, 0, 1);
 
-  calculate_ins_del_char_costs (screen);
+  calculate_ins_del_char_costs (frame);
 
   /* Don't use TS_repeat if its padding is worse than sending the chars */
   if (TS_repeat && per_line_cost (TS_repeat) * baud_rate < 9000)
     RPov = string_cost (TS_repeat);
   else
-    RPov = SCREEN_WIDTH (screen) * 2;
+    RPov = FRAME_WIDTH (frame) * 2;
 
   cmcostinit ();                /* set up cursor motion costs */
 }
@@ -1151,7 +1151,7 @@ term_init (terminal_type)
   BackTab = tgetstr ("bt", address);
   TS_clr_to_bottom = tgetstr ("cd", address);
   TS_clr_line = tgetstr ("ce", address);
-  TS_clr_screen = tgetstr ("cl", address);
+  TS_clr_frame = tgetstr ("cl", address);
   ColPosition = tgetstr ("ch", address);
   AbsPosition = tgetstr ("cm", address);
   CR = tgetstr ("cr", address);
@@ -1209,7 +1209,7 @@ term_init (terminal_type)
   MultiRight = tgetstr ("RI", address);
 
   AutoWrap = tgetflag ("am");
-  memory_below_screen = tgetflag ("db");
+  memory_below_frame = tgetflag ("db");
   TF_hazeltine = tgetflag ("hz");
   must_write_spaces = tgetflag ("in");
   meta_key = tgetflag ("km") || tgetflag ("MT");
@@ -1222,13 +1222,13 @@ term_init (terminal_type)
 
   term_get_fkeys (address);
 
-  /* Get screen size from system, or else from termcap.  */
-  get_screen_size (&SCREEN_WIDTH (selected_screen),
-                   &SCREEN_HEIGHT (selected_screen));
-  if (SCREEN_WIDTH (selected_screen) <= 0)
-    SCREEN_WIDTH (selected_screen) = tgetnum ("co");
-  if (SCREEN_HEIGHT (selected_screen) <= 0)
-    SCREEN_HEIGHT (selected_screen) = tgetnum ("li");
+  /* Get frame size from system, or else from termcap.  */
+  get_frame_size (&FRAME_WIDTH (selected_frame),
+                   &FRAME_HEIGHT (selected_frame));
+  if (FRAME_WIDTH (selected_frame) <= 0)
+    FRAME_WIDTH (selected_frame) = tgetnum ("co");
+  if (FRAME_HEIGHT (selected_frame) <= 0)
+    FRAME_HEIGHT (selected_frame) = tgetnum ("li");
 
   min_padding_speed = tgetnum ("pb");
   TN_standout_width = tgetnum ("sg");
@@ -1285,7 +1285,7 @@ term_init (terminal_type)
 
   if (!strcmp (terminal_type, "supdup"))
     {
-      memory_below_screen = 1;
+      memory_below_frame = 1;
       Wcm.cm_losewrap = 1;
     }
   if (!strncmp (terminal_type, "c10", 3)
@@ -1296,7 +1296,7 @@ term_init (terminal_type)
          for windows starting at the upper left corner;
          but that is all Emacs uses.
 
-         This string works only if the screen is using
+         This string works only if the frame is using
          the top of the video memory, because addressing is memory-relative.
          So first check the :ti string to see if that is true.
 
@@ -1330,9 +1330,9 @@ term_init (terminal_type)
         }
     }
 
-  ScreenRows = SCREEN_HEIGHT (selected_screen);
-  ScreenCols = SCREEN_WIDTH (selected_screen);
-  specified_window = SCREEN_HEIGHT (selected_screen);
+  FrameRows = FRAME_HEIGHT (selected_frame);
+  FrameCols = FRAME_WIDTH (selected_frame);
+  specified_window = FRAME_HEIGHT (selected_frame);
 
   if (Wcm_init () == -1)        /* can't do cursor motion */
 #ifdef VMS
@@ -1350,9 +1350,9 @@ use the C-shell command `setenv TERM ...' to specify the correct type.\n\
 It may be necessary to do `unsetenv TERMCAP' as well.\n",
            terminal_type);
 #endif
-  if (SCREEN_HEIGHT (selected_screen) <= 0
-      || SCREEN_WIDTH (selected_screen) <= 0)
-    fatal ("The screen size has not been specified.");
+  if (FRAME_HEIGHT (selected_frame) <= 0
+      || FRAME_WIDTH (selected_frame) <= 0)
+    fatal ("The frame size has not been specified.");
 
   delete_in_insert_mode
     = TS_delete_mode && TS_insert_mode
@@ -1364,7 +1364,7 @@ It may be necessary to do `unsetenv TERMCAP' as well.\n",
 
   /* Remove width of standout marker from usable width of line */
   if (TN_standout_width > 0)
-    SCREEN_WIDTH (selected_screen) -= TN_standout_width;
+    FRAME_WIDTH (selected_frame) -= TN_standout_width;
 
   UseTabs = tabs_safe_p () && TabWidth == 8;