Merged in changes from CVS trunk.
[bpt/emacs.git] / src / termhooks.h
index 3c1afc0..ba677e9 100644 (file)
@@ -1,6 +1,5 @@
-/* Hooks by which low level terminal operations
-   can be made to call other routines.
-   Copyright (C) 1985, 1986, 1993, 1994 Free Software Foundation, Inc.
+/* Parameters and display hooks for output devices
+   Copyright (C) 1985,86,93,94,2003  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -16,179 +15,36 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GNU Emacs; see the file COPYING.  If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
 
 \f
 /* Miscellanea.   */
 
-/* If nonzero, send all terminal output characters to this stream also.  */
-extern FILE *termscript;
-
-\f
-/* Text display hooks.  */
-
-extern int (*cursor_to_hook) ();
-extern int (*raw_cursor_to_hook) ();
-
-extern int (*clear_to_end_hook) ();
-extern int (*clear_frame_hook) ();
-extern int (*clear_end_of_line_hook) ();
-
-extern int (*ins_del_lines_hook) ();
-
-extern int (*change_line_highlight_hook) ();
-extern int (*reassert_line_highlight_hook) ();
-
-extern int (*insert_glyphs_hook) ();
-extern int (*write_glyphs_hook) ();
-extern int (*delete_glyphs_hook) ();
-
-extern int (*ring_bell_hook) ();
-
-extern int (*reset_terminal_modes_hook) ();
-extern int (*set_terminal_modes_hook) ();
-extern int (*update_begin_hook) ();
-extern int (*update_end_hook) ();
-extern int (*set_terminal_window_hook) ();
-
+struct glyph;
+struct frame;
 
+/* Only use prototypes when lisp.h has been included.  */
+#ifndef P_
+#define P_(X) ()
+#endif
 \f
-/* Multi-frame and mouse support hooks.  */
 
 enum scroll_bar_part {
   scroll_bar_above_handle,
   scroll_bar_handle,
-  scroll_bar_below_handle
+  scroll_bar_below_handle,
+  scroll_bar_up_arrow,
+  scroll_bar_down_arrow,
+  scroll_bar_to_top,
+  scroll_bar_to_bottom,
+  scroll_bar_end_scroll,
+  scroll_bar_move_ratio
 };
 
-/* Return the current position of the mouse.
-
-   Set *f to the frame the mouse is in, or zero if the mouse is in no
-   Emacs frame.  If it is set to zero, all the other arguments are
-   garbage.
-
-   If the motion started in a scroll bar, set *bar_window to the
-   scroll bar's window, *part to the part the mouse is currently over,
-   *x to the position of the mouse along the scroll bar, and *y to the
-   overall length of the scroll bar.
-
-   Otherwise, set *bar_window to Qnil, and *x and *y to the column and
-   row of the character cell the mouse is over.
-
-   Set *time to the time the mouse was at the returned position.
-
-   This should clear mouse_moved until the next motion
-   event arrives.  */
-extern void (*mouse_position_hook) ( /* FRAME_PTR *f,
-                                       Lisp_Object *bar_window,
-                                       enum scroll_bar_part *part,
-                                       Lisp_Object *x,
-                                       Lisp_Object *y,
-                                       unsigned long *time */ );
-
-/* The window system handling code should set this if the mouse has
-   moved since the last call to the mouse_position_hook.  Calling that
-   hook should clear this.  */
-extern int mouse_moved;
-
-/* When a frame's focus redirection is changed, this hook tells the
-   window system code to re-decide where to put the highlight.  Under
-   X, this means that Emacs lies about where the focus is.  */
-extern void (*frame_rehighlight_hook) ( /* void */ );
-
-/* If we're displaying frames using a window system that can stack
-   frames on top of each other, this hook allows you to bring a frame
-   to the front, or bury it behind all the other windows.  If this
-   hook is zero, that means the device we're displaying on doesn't
-   support overlapping frames, so there's no need to raise or lower
-   anything.
-
-   If RAISE is non-zero, F is brought to the front, before all other
-   windows.  If RAISE is zero, F is sent to the back, behind all other
-   windows.  */
-extern void (*frame_raise_lower_hook) ( /* FRAME_PTR f, int raise */ );
-
-\f
-/* Scroll bar hooks.  */
-
-/* The representation of scroll bars is determined by the code which
-   implements them, except for one thing: they must be represented by
-   lisp objects.  This allows us to place references to them in
-   Lisp_Windows without worrying about those references becoming
-   dangling references when the scroll bar is destroyed.
-
-   The window-system-independent portion of Emacs just refers to
-   scroll bars via their windows, and never looks inside the scroll bar
-   representation; it always uses hook functions to do all the
-   scroll bar manipulation it needs.
-
-   The `vertical_scroll_bar' field of a Lisp_Window refers to that
-   window's scroll bar, or is nil if the window doesn't have a
-   scroll bar.
-
-   The `scroll_bars' and `condemned_scroll_bars' fields of a Lisp_Frame
-   are free for use by the scroll bar implementation in any way it sees
-   fit.  They are marked by the garbage collector.  */
-
-
-/* Set the vertical scroll bar for WINDOW to have its upper left corner
-   at (TOP, LEFT), and be LENGTH rows high.  Set its handle to
-   indicate that we are displaying PORTION characters out of a total
-   of WHOLE characters, starting at POSITION.  If WINDOW doesn't yet
-   have a scroll bar, create one for it.  */
-extern void (*set_vertical_scroll_bar_hook)
-            ( /* struct window *window,
-                int portion, int whole, int position */ );
-
-
-/* The following three hooks are used when we're doing a thorough
-   redisplay of the frame.  We don't explicitly know which scroll bars
-   are going to be deleted, because keeping track of when windows go
-   away is a real pain - can you say set-window-configuration?
-   Instead, we just assert at the beginning of redisplay that *all*
-   scroll bars are to be removed, and then save scroll bars from the
-   firey pit when we actually redisplay their window.  */
-
-/* Arrange for all scroll bars on FRAME to be removed at the next call
-   to `*judge_scroll_bars_hook'.  A scroll bar may be spared if
-   `*redeem_scroll_bar_hook' is applied to its window before the judgement. 
-
-   This should be applied to each frame each time its window tree is
-   redisplayed, even if it is not displaying scroll bars at the moment;
-   if the HAS_SCROLL_BARS flag has just been turned off, only calling
-   this and the judge_scroll_bars_hook will get rid of them.
-
-   If non-zero, this hook should be safe to apply to any frame,
-   whether or not it can support scroll bars, and whether or not it is
-   currently displaying them.  */
-extern void (*condemn_scroll_bars_hook)( /* FRAME_PTR *frame */ );
-
-/* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
-   Note that it's okay to redeem a scroll bar that is not condemned.  */
-extern void (*redeem_scroll_bar_hook)( /* struct window *window */ );
-
-/* Remove all scroll bars on FRAME that haven't been saved since the
-   last call to `*condemn_scroll_bars_hook'.  
-
-   This should be applied to each frame after each time its window
-   tree is redisplayed, even if it is not displaying scroll bars at the
-   moment; if the HAS_SCROLL_BARS flag has just been turned off, only
-   calling this and condemn_scroll_bars_hook will get rid of them.
-
-   If non-zero, this hook should be safe to apply to any frame,
-   whether or not it can support scroll bars, and whether or not it is
-   currently displaying them.  */
-extern void (*judge_scroll_bars_hook)( /* FRAME_PTR *FRAME */ );
-
 \f
 /* Input queue declarations and hooks.  */
 
-/* Called to read input events.  */
-extern int (*read_socket_hook) ();
-
-/* Called when a frame's display becomes entirely up to date.  */
-extern int (*frame_up_to_date_hook) ();
-
 /* Expedient hack: only provide the below definitions to files that
    are prepared to handle lispy things.  CONSP is defined iff lisp.h
    has been included before this file.  */
@@ -196,10 +52,10 @@ extern int (*frame_up_to_date_hook) ();
 
 enum event_kind
 {
-  no_event,                    /* nothing happened.  This should never
+  NO_EVENT,                    /* nothing happened.  This should never
                                   actually appear in the event queue.  */
 
-  ascii_keystroke,             /* The ASCII code is in .code, perhaps
+  ASCII_KEYSTROKE_EVENT,       /* The ASCII code is in .code, perhaps
                                   with modifiers applied.
                                   .modifiers holds the state of the
                                   modifier keys.
@@ -207,7 +63,11 @@ enum event_kind
                                   which the key was typed.
                                   .timestamp gives a timestamp (in
                                   milliseconds) for the keystroke.  */
-  non_ascii_keystroke,         /* .code is a number identifying the
+  MULTIBYTE_CHAR_KEYSTROKE_EVENT,      /* The multibyte char code is in .code,
+                                  perhaps with modifiers applied.
+                                  The others are the same as
+                                  ASCII_KEYSTROKE_EVENT.  */
+  NON_ASCII_KEYSTROKE_EVENT,   /* .code is a number identifying the
                                   function key.  A code N represents
                                   a key whose name is
                                   function_key_names[N]; function_key_names
@@ -219,7 +79,8 @@ enum event_kind
                                   which the key was typed.
                                   .timestamp gives a timestamp (in
                                   milliseconds) for the keystroke.  */
-  mouse_click,                 /* The button number is in .code; it must
+  TIMER_EVENT,                  /* A timer fired.  */
+  MOUSE_CLICK_EVENT,           /* The button number is in .code; it must
                                   be >= 0 and < NUM_MOUSE_BUTTONS, defined
                                   below.
                                   .modifiers holds the state of the
@@ -230,7 +91,25 @@ enum event_kind
                                   the mouse click occurred in.
                                   .timestamp gives a timestamp (in
                                   milliseconds) for the click.  */
-  scroll_bar_click,            /* .code gives the number of the mouse button
+  WHEEL_EVENT,                 /* A wheel event is generated by a
+                                  wheel on a mouse (e.g., MS
+                                  Intellimouse).
+                                  .modifiers holds the rotate
+                                  direction (up or down), and the
+                                  state of the modifier keys.
+                                  .x and .y give the mouse position,
+                                  in characters, within the window.
+                                  .frame_or_window gives the frame
+                                  the wheel event occurred in.
+                                  .timestamp gives a timestamp (in
+                                  milliseconds) for the event.  */
+#ifdef WINDOWSNT
+  LANGUAGE_CHANGE_EVENT,       /* A LANGUAGE_CHANGE_EVENT is generated
+                                  on WINDOWSNT when the keyboard layout
+                                  or input language is changed by the
+                                  user.  */
+#endif
+  SCROLL_BAR_CLICK_EVENT,      /* .code gives the number of the mouse button
                                   that was clicked.
                                   .modifiers holds the state of the modifier
                                   keys.
@@ -243,19 +122,64 @@ enum event_kind
                                   whose scroll bar was clicked in.
                                   .timestamp gives a timestamp (in
                                   milliseconds) for the click.  */
-  selection_request_event,     /* Another X client wants a selection from us.
+#ifdef WINDOWSNT
+  W32_SCROLL_BAR_CLICK_EVENT,  /* as for SCROLL_BAR_CLICK, but only generated
+                                  by MS-Windows scroll bar controls. */
+#endif
+  SELECTION_REQUEST_EVENT,     /* Another X client wants a selection from us.
                                   See `struct selection_event'.  */
-  selection_clear_event,       /* Another X client cleared our selection.  */
-  buffer_switch_event,         /* A process filter has switched buffers.  */
-  delete_window_event,         /* An X client said "delete this window".  */
-  menu_bar_event               /* An event generated by the menu bar.
-                                  The frame_or_window field holds the
+  SELECTION_CLEAR_EVENT,       /* Another X client cleared our selection.  */
+  BUFFER_SWITCH_EVENT,         /* A process filter has switched buffers.  */
+  DELETE_WINDOW_EVENT,         /* An X client said "delete this window".  */
+  MENU_BAR_EVENT,              /* An event generated by the menu bar.
+                                  The frame_or_window field's cdr holds the
                                   Lisp-level event value.
                                   (Only the toolkit version uses these.)  */
+  ICONIFY_EVENT,               /* An X client iconified this window.  */
+  DEICONIFY_EVENT,             /* An X client deiconified this window.  */
+  MENU_BAR_ACTIVATE_EVENT,      /* A button press in the menu bar
+                                  (toolkit version only).  */
+  DRAG_N_DROP_EVENT,           /* A drag-n-drop event is generated when
+                                  files selected outside of Emacs are dropped
+                                  onto an Emacs window.
+                                  Currently used only on Windows NT.
+                                  .modifiers holds the state of the
+                                  modifier keys.
+                                  .x and .y give the mouse position,
+                                  in characters, within the window.
+                                  .frame_or_window is a cons of the frame
+                                  in which the drop was made and a list of
+                                  the filenames of the dropped files.
+                                  .timestamp gives a timestamp (in
+                                  milliseconds) for the click.  */
+  USER_SIGNAL_EVENT,           /* A user signal.
+                                   code is a number identifying it,
+                                   index into lispy_user_signals.  */
+
+  /* Help events.  Member `frame_or_window' of the input_event is the
+     frame on which the event occurred, and member `arg' contains
+     the help to show.  */
+  HELP_EVENT,
+
+  /* An event from a tool-bar.  Member `arg' of the input event
+     contains the tool-bar item selected.  If `frame_or_window'
+     and `arg' are equal, this is a prefix event.  */
+  TOOL_BAR_EVENT,
+
+  /* Queued from XTread_socket on FocusIn events.  Translated into
+     `switch-frame' events in kbd_buffer_get_event, if necessary.  */
+  FOCUS_IN_EVENT,
+
+  /* Generated when mouse moves over window not currently selected.  */
+  SELECT_WINDOW_EVENT,
+
+  /* Queued from XTread_socket when session manager sends
+     save yourself before shutdown. */
+  SAVE_SESSION_EVENT
 };
 
-/* If a struct input_event has a kind which is selection_request_event
-   or selection_clear_event, then its contents are really described
+/* If a struct input_event has a kind which is SELECTION_REQUEST_EVENT
+   or SELECTION_CLEAR_EVENT, then its contents are really described
    by `struct selection_event'; see xterm.h.  */
 
 /* The keyboard input buffer is an array of these structures.  Each one
@@ -263,36 +187,46 @@ enum event_kind
    a window system event.  These get turned into their lispy forms when
    they are removed from the event queue.  */
 
-struct input_event {
-
+struct input_event
+{
   /* What kind of event was this?  */
   enum event_kind kind;
-  
-  /* For an ascii_keystroke, this is the character.
-     For a non_ascii_keystroke, this is the keysym code.
+
+  /* For an ASCII_KEYSTROKE_EVENT and MULTIBYTE_CHAR_KEYSTROKE_EVENT,
+     this is the character.
+     For a NON_ASCII_KEYSTROKE_EVENT, this is the keysym code.
      For a mouse event, this is the button number.  */
+  /* In WindowsNT, for a mouse wheel event, this is the delta.  */
   int code;
   enum scroll_bar_part part;
 
-  /* This field is copied into a vector while the event is in the queue,
-     so that garbage collections won't kill it.  */
-  /* In a menu_bar_event, this holds the Lisp object
-     that is the event's value.  */
-  Lisp_Object frame_or_window;
-
   int modifiers;               /* See enum below for interpretation.  */
 
   Lisp_Object x, y;
   unsigned long timestamp;
+
+  /* This is padding just to put the frame_or_window field
+     past the size of struct selection_event.  */
+  int *padding[2];
+
+  /* This field is copied into a vector while the event is in the queue,
+     so that garbage collections won't kill it.  */
+  /* In a menu_bar_event, this is a cons cell whose car is the frame
+     and whose cdr is the Lisp object that is the event's value.  */
+  /* This field is last so that struct selection_input_event
+     does not overlap with it.  */
+  Lisp_Object frame_or_window;
+
+  /* Additional event argument.  This is used for TOOL_BAR_EVENTs and
+     HELP_EVENTs and avoids calling Fcons during signal handling.  */
+  Lisp_Object arg;
 };
-\f
-/* This is used in keyboard.c, to tell how many buttons we will need
-   to track the positions of.  */
-#define NUM_MOUSE_BUTTONS (5)
+
+#define EVENT_INIT(event) bzero (&(event), sizeof (struct input_event))
 
 /* Bits in the modifiers member of the input_event structure.
    Note that reorder_modifiers assumes that the bits are in canonical
-   order.  
+   order.
 
    The modifiers applied to mouse clicks are rather ornate.  The
    window-system-specific code should store mouse clicks with
@@ -339,4 +273,287 @@ enum {
   meta_modifier        =  CHAR_META    /* Under X, the XK_Meta_[LR] keysyms.  */
 };
 
+#endif /* CONSP */
+
+\f
+/* Display-local parameters. */
+struct display
+{
+  /* Chain of all displays. */
+  struct display *next_display;
+
+  /* The number of frames that are on this display. */
+  int reference_count;
+  
+  /* The type of the display. */
+  enum output_method type;
+
+  /* Display-type dependent data shared amongst all frames on this display. */
+  union display_info
+  {
+    struct tty_display_info *tty;     /* termchar.h */
+    struct x_display_info *x;         /* xterm.h */
+  } display_info;
+
+\f
+  /* Terminal characteristics. */
+  /* XXX Are these really used on non-termcap displays? */
+  
+  int must_write_spaces;       /* Nonzero means spaces in the text must
+                                  actually be output; can't just skip over
+                                  some columns to leave them blank.  */
+  int fast_clear_end_of_line;   /* Nonzero means terminal has a `ce' string */
+  
+  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 scroll_region_cost;      /* Cost of setting the scroll window,
+                                   measured in characters. */
+  int memory_below_frame;      /* Terminal remembers lines scrolled
+                                   off bottom */
+
+#if 0  /* These are not used anywhere. */
+  /* EMACS_INT baud_rate; */   /* Output speed in baud */
+  int min_padding_speed;       /* Speed below which no padding necessary. */
+  int dont_calculate_costs;     /* Nonzero means don't bother computing
+                                   various cost tables; we won't use them. */
+#endif
+
+\f
+  /* Window-based redisplay interface for this device (0 for tty
+     devices). */
+  struct redisplay_interface *rif;
+
+  /* Frame-based redisplay interface. */
+  
+  /* Text display hooks.  */
+
+  void (*cursor_to_hook) P_ ((struct frame *f, int vpos, int hpos));
+  void (*raw_cursor_to_hook) P_ ((struct frame *, int, int));
+  
+  void (*clear_to_end_hook) P_ ((struct frame *));
+  void (*clear_frame_hook) P_ ((struct frame *));
+  void (*clear_end_of_line_hook) P_ ((struct frame *, int));
+  
+  void (*ins_del_lines_hook) P_ ((struct frame *f, int, int));
+  
+  void (*insert_glyphs_hook) P_ ((struct frame *f, struct glyph *s, int n));
+  void (*write_glyphs_hook) P_ ((struct frame *f, struct glyph *s, int n));
+  void (*delete_glyphs_hook) P_ ((struct frame *, int));
+  
+  void (*ring_bell_hook) P_ ((struct frame *f));
+  
+  void (*reset_terminal_modes_hook) P_ ((struct display *));
+  void (*set_terminal_modes_hook) P_ ((struct display *));
+
+  void (*update_begin_hook) P_ ((struct frame *));
+  void (*update_end_hook) P_ ((struct frame *));
+  void (*set_terminal_window_hook) P_ ((struct frame *, int));
+
+  /* Multi-frame and mouse support hooks.  */
+
+  /* Return the current position of the mouse.
+
+     Set *f to the frame the mouse is in, or zero if the mouse is in no
+     Emacs frame.  If it is set to zero, all the other arguments are
+     garbage.
+  
+     If the motion started in a scroll bar, set *bar_window to the
+     scroll bar's window, *part to the part the mouse is currently over,
+     *x to the position of the mouse along the scroll bar, and *y to the
+     overall length of the scroll bar.
+
+     Otherwise, set *bar_window to Qnil, and *x and *y to the column and
+     row of the character cell the mouse is over.
+
+     Set *time to the time the mouse was at the returned position.
+     
+     This should clear mouse_moved until the next motion
+     event arrives.  */
+  void (*mouse_position_hook) P_ ((struct frame **f, int,
+                                   Lisp_Object *bar_window,
+                                   enum scroll_bar_part *part,
+                                   Lisp_Object *x,
+                                   Lisp_Object *y,
+                                   unsigned long *time));
+
+  /* The window system handling code should set this if the mouse has
+     moved since the last call to the mouse_position_hook.  Calling that
+     hook should clear this.  */
+  int mouse_moved;
+
+  /* When a frame's focus redirection is changed, this hook tells the
+     window system code to re-decide where to put the highlight.  Under
+     X, this means that Emacs lies about where the focus is.  */
+  void (*frame_rehighlight_hook) P_ ((struct frame *));
+
+  /* If we're displaying frames using a window system that can stack
+     frames on top of each other, this hook allows you to bring a frame
+     to the front, or bury it behind all the other windows.  If this
+     hook is zero, that means the device we're displaying on doesn't
+     support overlapping frames, so there's no need to raise or lower
+     anything.
+     
+     If RAISE is non-zero, F is brought to the front, before all other
+     windows.  If RAISE is zero, F is sent to the back, behind all other
+     windows.  */
+  void (*frame_raise_lower_hook) P_ ((struct frame *f, int raise));
+
+  \f
+  /* Scroll bar hooks.  */
+
+  /* The representation of scroll bars is determined by the code which
+     implements them, except for one thing: they must be represented by
+     lisp objects.  This allows us to place references to them in
+     Lisp_Windows without worrying about those references becoming
+     dangling references when the scroll bar is destroyed.
+     
+     The window-system-independent portion of Emacs just refers to
+     scroll bars via their windows, and never looks inside the scroll bar
+     representation; it always uses hook functions to do all the
+     scroll bar manipulation it needs.
+     
+     The `vertical_scroll_bar' field of a Lisp_Window refers to that
+     window's scroll bar, or is nil if the window doesn't have a
+     scroll bar.
+     
+     The `scroll_bars' and `condemned_scroll_bars' fields of a Lisp_Frame
+     are free for use by the scroll bar implementation in any way it sees
+     fit.  They are marked by the garbage collector.  */
+  
+  
+  /* Set the vertical scroll bar for WINDOW to have its upper left corner
+     at (TOP, LEFT), and be LENGTH rows high.  Set its handle to
+     indicate that we are displaying PORTION characters out of a total
+     of WHOLE characters, starting at POSITION.  If WINDOW doesn't yet
+     have a scroll bar, create one for it.  */
+  void (*set_vertical_scroll_bar_hook) P_ ((struct window *window,
+                                            int portion, int whole,
+                                            int position));
+
+
+  /* The following three hooks are used when we're doing a thorough
+     redisplay of the frame.  We don't explicitly know which scroll bars
+     are going to be deleted, because keeping track of when windows go
+     away is a real pain - can you say set-window-configuration?
+     Instead, we just assert at the beginning of redisplay that *all*
+     scroll bars are to be removed, and then save scroll bars from the
+     fiery pit when we actually redisplay their window.  */
+  
+  /* Arrange for all scroll bars on FRAME to be removed at the next call
+     to `*judge_scroll_bars_hook'.  A scroll bar may be spared if
+     `*redeem_scroll_bar_hook' is applied to its window before the judgement.
+     
+     This should be applied to each frame each time its window tree is
+     redisplayed, even if it is not displaying scroll bars at the moment;
+     if the HAS_SCROLL_BARS flag has just been turned off, only calling
+     this and the judge_scroll_bars_hook will get rid of them.
+     
+     If non-zero, this hook should be safe to apply to any frame,
+     whether or not it can support scroll bars, and whether or not it is
+     currently displaying them.  */
+  void (*condemn_scroll_bars_hook) P_ ((struct frame *frame));
+
+  /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
+     Note that it's okay to redeem a scroll bar that is not condemned.  */
+  void (*redeem_scroll_bar_hook) P_ ((struct window *window));
+
+  /* Remove all scroll bars on FRAME that haven't been saved since the
+     last call to `*condemn_scroll_bars_hook'.
+
+     This should be applied to each frame after each time its window
+     tree is redisplayed, even if it is not displaying scroll bars at the
+     moment; if the HAS_SCROLL_BARS flag has just been turned off, only
+     calling this and condemn_scroll_bars_hook will get rid of them.
+     
+     If non-zero, this hook should be safe to apply to any frame,
+     whether or not it can support scroll bars, and whether or not it is
+     currently displaying them.  */
+  void (*judge_scroll_bars_hook) P_ ((struct frame *FRAME));
+
+\f
+  /* Called to read input events.
+
+     DISPLAY indicates which display to read from.  Input events
+     should be read into BUF, the size of which is given in SIZE.
+     EXPECTED is non-zero if the caller suspects that new input is
+     available.
+
+     A positive return value indicates that that many input events
+     where read into BUF.
+     Zero means no events were immediately available.
+     A value of -1 means a transient read error, while -2 indicates
+     that the display was closed (hangup), and it should be deleted.
+
+     XXX Please note that a non-zero value of EXPECTED only means that
+     there is available input on at least one of the currently opened
+     display devices -- but not necessarily on this device.
+     Therefore, in most cases EXPECTED should be simply ignored.
+
+     XXX This documentation needs to be updated.  */
+  int (*read_socket_hook) P_ ((struct display *display,
+                               int expected,
+                               struct input_event *hold_quit));
+
+  /* Called when a frame's display becomes entirely up to date.  */
+  void (*frame_up_to_date_hook) P_ ((struct frame *));
+
+\f
+  /* Called to delete the device-specific portions of a frame that is
+     on this display. */
+  void (*delete_frame_hook) P_ ((struct frame *));
+
+  /* Called after the last frame on this display is deleted, or when
+     the display device was closed (hangup).
+     
+     If this is NULL, then the generic delete_display() is called
+     instead.
+
+     The hook must check for and close any live frames that are still
+     on the display.  Fdelete_frame ensures that there are no live
+     frames on the display when it calls this hook, so infinite
+     recursion is prevented.  */
+  void (*delete_display_hook) P_ ((struct display *));
+};
+
+
+/* Chain of all displays currently in use. */
+extern struct display *display_list;
+
+#define FRAME_MUST_WRITE_SPACES(f) ((f)->display->must_write_spaces)
+#define FRAME_FAST_CLEAR_END_OF_LINE(f) ((f)->display->fast_clear_end_of_line)
+#define FRAME_LINE_INS_DEL_OK(f) ((f)->display->line_ins_del_ok)
+#define FRAME_CHAR_INS_DEL_OK(f) ((f)->display->char_ins_del_ok)
+#define FRAME_SCROLL_REGION_OK(f) ((f)->display->scroll_region_ok)
+#define FRAME_SCROLL_REGION_COST(f) ((f)->display->scroll_region_cost)
+#define FRAME_MEMORY_BELOW_FRAME(f) ((f)->display->memory_below_frame)
+
+#define FRAME_RIF(f) ((f)->display->rif)
+
+#define FRAME_DISPLAY(f) ((f)->display)
+
+/* FRAME_WINDOW_P tests whether the frame is a window, and is
+   defined to be the predicate for the window system being used.  */
+
+#ifdef HAVE_X_WINDOWS
+#define FRAME_WINDOW_P(f) FRAME_X_P (f)
 #endif
+#ifdef HAVE_NTGUI
+#define FRAME_WINDOW_P(f) FRAME_W32_P (f)
+#endif
+#ifdef MAC_OS
+#define FRAME_WINDOW_P(f) FRAME_MAC_P (f)
+#endif
+#ifndef FRAME_WINDOW_P
+#define FRAME_WINDOW_P(f) (0)
+#endif
+
+extern struct display *create_display P_ ((void));
+extern void delete_display P_ ((struct display *));
+
+/* The initial display device, created by initial_term_init. */
+extern struct display *initial_display;
+
+/* arch-tag: 33a00ecc-52b5-4186-a410-8801ac9f087d
+   (do not change this comment) */