From: CSRG <csrg@ucbvax.Berkeley.EDU>
Date: Thu, 10 Apr 1986 16:32:08 +0000 (-0800)
Subject: BSD 4_3 development
X-Git-Tag: BSD-4_3~306
X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/commitdiff_plain/97d9062832d01e2fcf8950903c41b1333df912d1

BSD 4_3 development
Work on file usr/contrib/emacs/src/xfns.c

Synthesized-from: CSRG/cd1/4.3
---

diff --git a/usr/contrib/emacs/src/xfns.c b/usr/contrib/emacs/src/xfns.c
new file mode 100644
index 0000000000..f0e92e6134
--- /dev/null
+++ b/usr/contrib/emacs/src/xfns.c
@@ -0,0 +1,1170 @@
+/* Functions for the X window system.
+   Copyright (C) 1985 Free Software Foundation.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY.  No author or distributor
+accepts responsibility to anyone for the consequences of using it
+or for whether it serves any particular purpose or works at all,
+unless he says so in writing.  Refer to the GNU Emacs General Public
+License for full details.
+
+Everyone is granted permission to copy, modify and redistribute
+GNU Emacs, but only under the conditions described in the
+GNU Emacs General Public License.   A copy of this license is
+supposed to have been given to you along with GNU Emacs so you
+can know your rights and responsibilities.  It should be in a
+file named COPYING.  Among other things, the copyright notice
+and this notice must be preserved on all copies.  */
+
+/* Written by Yakim Martillo; rearranged by Richard Stallman.  */
+/* Color added by Robert Krawitz*/
+
+/*#include <stdio.h>*/
+#include "config.h"
+#include "lisp.h"
+#include "window.h"
+#include "xterm.h"
+#include "dispextern.h"
+#include "termchar.h"
+#include <signal.h>
+#include "sink.h"
+#include "sinkmask.h"
+#include <sys/time.h>
+#include <fcntl.h>
+#include <setjmp.h>
+
+#define abs(x) ((x < 0) ? ((x)) : (x))
+#define sgn(x) ((x < 0) ? (-1) : (1))
+  
+#define CROSS_WIDTH 16
+#define CROSS_HEIGHT 16
+
+static short cross_bits[] =
+  {
+    0x0000, 0x0180, 0x0180, 0x0180,
+    0x0180, 0x0180, 0x0180, 0x7ffe,
+    0x7ffe, 0x0180, 0x0180, 0x0180,
+    0x0180, 0x0180, 0x0180, 0x0000,
+  };
+
+static short gray_bits[] = {
+    0xaaaa, 0x5555, 0xaaaa, 0x5555,
+    0xaaaa, 0x5555, 0xaaaa, 0x5555,
+    0xaaaa, 0x5555, 0xaaaa, 0x5555,
+    0xaaaa, 0x5555, 0xaaaa, 0x5555};
+
+#define CROSS_MASK_WIDTH 16
+#define CROSS_MASK_HEIGHT 16
+static short cross_mask_bits[] =
+  {
+    0x03c0, 0x03c0, 0x03c0, 0x03c0,
+    0x03c0, 0x03c0, 0xffff, 0xffff,
+    0xffff, 0xffff, 0x03c0, 0x03c0,
+    0x03c0, 0x03c0, 0x03c0, 0x03c0,
+  };
+
+extern XREPBUFFER Xxrepbuffer;
+
+/* Non-nil if Emacs is running with an X window for display.
+   Nil if Emacs is run on an ordinary terminal.  */
+
+Lisp_Object Vxterm;
+
+Lisp_Object Vx_mouse_pos;
+
+extern struct Lisp_Vector *MouseMap;
+
+extern char *fore_color;
+extern char *back_color;
+extern char *brdr_color;
+extern char *mous_color;
+extern char *curs_color;
+
+extern int fore;
+extern int back;
+extern int brdr;
+extern int mous;
+extern int curs;
+
+/* Nonzero if x-set-window-edges has been called
+   or x-rubber-band has been called.
+   If it is zero when x-pop-up-window is called,
+   x-rubber-band is called at that point.  */
+
+int x_edges_specified;
+
+check_xterm ()
+{
+  if (NULL (Vxterm))
+    error ("Terminal does not understand X protocol.");
+}
+
+DEFUN ("x-pop-up-window", Fx_pop_up_window, Sx_pop_up_window, 0, 0, 0,
+  "Make the X window appear on the screen.")
+  ()
+{
+  check_xterm();
+  XPopUpWindow();
+  return Qnil;
+}
+
+DEFUN ("x-set-bell", Fx_set_bell, Sx_set_bell, 1, 1, "P",
+  "For X window system, set audible vs visible bell.\n\
+With non-nil argument (prefix arg), use visible bell; otherwise, audible bell.")
+  (arg)
+     Lisp_Object arg;
+{
+  check_xterm ();
+  if (!NULL (arg))
+    XSetFlash ();
+  else
+    XSetFeep ();
+  return arg;
+}
+
+DEFUN ("x-flip-color", Fx_flip_color, Sx_flip_color, 0, 0, "",
+  "Toggle the background and foreground colors (currently only black \n\
+and white -- by default background is white -- Only effective at init")
+  ()
+{
+  check_xterm ();
+  XFlipColor ();
+  return Qt;
+}
+
+DEFUN ("x-set-foreground-color", Fx_set_foreground_color,
+       Sx_set_foreground_color, 1, 1, "sSet foregroud color:  ",
+       "Set foreground (text) color to COLOR.")
+(arg)
+Lisp_Object arg;
+{
+    Color cdef;
+    extern int PendingExposure;
+    int (*func) ();
+    extern Window XXwindow;
+    extern FontInfo *fontinfo;
+    char *save_color;
+    save_color = fore_color;
+    check_xterm ();
+    CHECK_STRING (arg,1);
+    fore_color = (char *) xmalloc (XSTRING (arg)->size + 1);
+    func = signal (SIGIO, SIG_IGN);
+    bcopy (XSTRING (arg)->data, fore_color, XSTRING (arg)->size + 1);
+    if (fore_color && DisplayCells() > 2 &&
+	XParseColor(fore_color, &cdef) && XGetHardwareColor(&cdef)) {
+	fore = cdef.pixel;
+    } else if (fore_color && strcmp(fore_color, "black") == 0) {
+	fore = BlackPixel;
+    } else if (fore_color && strcmp(fore_color, "white") == 0) {
+	fore = WhitePixel;
+    }
+    else
+      {
+	  fore_color = save_color;
+      }
+/*    XPixFill (XXwindow, 0, 0, screen_width * fontinfo->width,
+	      screen_height * fontinfo->height, back, ClipModeClipped,
+	      GXcopy, AllPlanes);*/
+    Fredraw_display ();
+/*    dumprectangle(0, 0, screen_height * fontinfo->height,
+		  screen_width * fontinfo -> width);*/
+/*    PendingExposure = 1;
+      xfixscreen ();*/
+    (void) signal (SIGIO, func);
+    XFlush();
+    return Qt;
+}
+
+DEFUN ("x-set-background-color", Fx_set_background_color,
+       Sx_set_background_color, 1, 1, "sSet background color:  ",
+       "Set background color to COLOR.")
+(arg)
+Lisp_Object arg;
+{
+    Color cdef;
+    extern int PendingExposure;
+    Pixmap temp;
+    int (*func) ();
+    char *save_color;
+    extern Window XXwindow;
+    check_xterm ();
+    CHECK_STRING (arg,1);
+    back_color = (char *) xmalloc (XSTRING (arg)->size + 1);
+    bcopy (XSTRING (arg)->data, back_color, XSTRING (arg)->size + 1);
+    func = signal (SIGIO, SIG_IGN);
+    if (back_color && DisplayCells() > 2 &&
+	XParseColor(back_color, &cdef) && XGetHardwareColor(&cdef)) {
+	back = cdef.pixel;
+    } else if (back_color && strcmp(back_color, "white") == 0) {
+	back = WhitePixel;
+    } else if (back_color && strcmp(back_color, "black") == 0) {
+	back = BlackPixel;
+    }
+    else
+      {
+	  back_color = save_color;
+      }
+    temp = XMakeTile(back);
+    XChangeBackground (XXwindow, temp);
+/*    XPixFill (XXwindow, 0, 0, screen_width * fontinfo->width,
+	      screen_height * fontinfo->height, back, ClipModeClipped,
+	      GXcopy, AllPlanes);*/
+    (void) signal (SIGIO, func);
+    Fredraw_display();
+/*    dumprectangle(0, 0, screen_height * fontinfo->height,
+		  screen_width * fontinfo -> width);*/
+/*    PendingExposure = 1;
+      xfixscreen ();*/
+    XFlush();
+    XFreePixmap (temp);
+    return Qt;
+}
+
+DEFUN ("x-set-border-color", Fx_set_border_color, Sx_set_border_color, 1, 1,
+       "sSet border color:  ",
+       "Set border color to COLOR.")
+(arg)
+Lisp_Object arg;
+{
+    Color cdef;
+    Pixmap temp;
+    extern int XXborder;
+    int (*func) ();
+    extern Window XXwindow;
+    check_xterm ();
+    CHECK_STRING (arg,1);
+    brdr_color= (char *) xmalloc (XSTRING (arg)->size + 1);
+    bcopy (XSTRING (arg)->data, brdr_color, XSTRING (arg)->size + 1);
+    func = signal (SIGIO, SIG_IGN);
+    if (brdr_color && DisplayCells() > 2 &&
+	XParseColor(brdr_color, &cdef) && XGetHardwareColor(&cdef))
+      {
+	  temp = XMakeTile(cdef.pixel);
+	  brdr = cdef.pixel;
+      }
+    else if (brdr_color && strcmp(brdr_color, "black") == 0)
+      {
+	  temp = BlackPixmap;
+	  brdr = BlackPixel;
+      }
+    else if (brdr_color && strcmp(brdr_color, "white") == 0)
+      {
+	  temp = WhitePixmap;
+	  brdr = WhitePixel;
+      }
+    else
+      {
+	  temp = XMakePixmap ((Bitmap) XStoreBitmap (16, 16, gray_bits),
+			      BlackPixel, WhitePixel);
+	  brdr = BlackPixel;
+	  brdr_color = "gray";
+      }
+    if (XXborder)
+      XChangeBorder (XXwindow, temp);
+    (void) signal (SIGIO, func);
+    XFreePixmap (temp);
+    return Qt;
+}
+
+DEFUN ("x-set-cursor-color", Fx_set_cursor_color, Sx_set_cursor_color, 1, 1,
+       "sSet text cursor color:  ",
+       "Set text cursor color to COLOR.")
+(arg)
+Lisp_Object arg;
+{
+    Color cdef;
+    extern Window XXwindow;
+    int (*func) ();
+    char *save_color;
+    check_xterm ();
+    CHECK_STRING (arg,1);
+    curs_color = (char *) xmalloc (XSTRING (arg)->size + 1);
+    func = signal (SIGIO, SIG_IGN);
+    bcopy (XSTRING (arg)->data, curs_color, XSTRING (arg)->size + 1);
+    if (curs_color && DisplayCells() > 2 &&
+	XParseColor(curs_color, &cdef) && XGetHardwareColor(&cdef)) {
+	curs = cdef.pixel;
+    } else if (curs_color && strcmp(curs_color, "black") == 0) {
+	curs = BlackPixel;
+    } else if (curs_color && strcmp(curs_color, "white") == 0) {
+	curs = WhitePixel;
+    }
+    else
+      {
+	  curs_color = save_color;
+      }
+    (void) signal (SIGIO, func);
+    CursorToggle();
+    CursorToggle();
+    return Qt;
+}
+
+DEFUN ("x-set-mouse-color", Fx_set_mouse_color, Sx_set_mouse_color, 1, 1,
+       "sSet mouse cursor color:  ",
+       "Set mouse cursor color to COLOR.")
+(arg)
+Lisp_Object arg;
+{
+    extern Cursor EmacsCursor;
+    extern char MouseCursor[], MouseMask[];
+    Cursor temp;
+    int (*func) ();
+    Color cdef;
+    char *save_color;
+    extern Window XXwindow;
+    check_xterm ();
+    CHECK_STRING (arg,1);
+    mous_color = (char *) xmalloc (XSTRING (arg)->size + 1);
+    func = signal (SIGIO, SIG_IGN);
+    bcopy (XSTRING (arg)->data, mous_color, XSTRING (arg)->size + 1);
+    if (mous_color && DisplayCells() > 2 &&
+	XParseColor(mous_color, &cdef) && XGetHardwareColor(&cdef)) {
+	mous = cdef.pixel;
+    } else if (mous_color && strcmp(mous_color, "black") == 0) {
+	mous = BlackPixel;
+    } else if (mous_color && strcmp(mous_color, "white") == 0) {
+	mous = WhitePixel;
+    }
+    else
+      {
+	  mous_color = save_color;
+      }
+    temp = XCreateCursor(16, 16, MouseCursor, MouseMask, 0, 0,
+				mous, back, GXcopy);
+    XDefineCursor (XXwindow, temp);
+    XFreeCursor (EmacsCursor);
+    (void) signal (SIGIO, func);
+    bcopy(&temp, &EmacsCursor, sizeof(Cursor));
+    return Qt;
+}   
+
+DEFUN ("x-color-p", Fx_color_p, Sx_color_p, 0, 0, "",
+       "Returns t if the display is a color X terminal.")
+()
+{
+    check_xterm ();
+    if (DisplayCells() > 2)
+      return Qt;
+    else
+      return Qnil;
+}
+	
+DEFUN ("x-get-foreground-color", Fx_get_foreground_color,
+       Sx_get_foreground_color, 0, 0, "",
+       "Returns the color of the foreground, as a string.")
+()
+{
+    Lisp_Object string;
+    string = make_string(fore_color, strlen (fore_color));
+    return string;
+}
+
+DEFUN ("x-get-background-color", Fx_get_background_color,
+       Sx_get_background_color, 0, 0, "",
+       "Returns the color of the background, as a string.")
+()
+{
+    Lisp_Object string;
+    string = make_string(back_color, strlen (back_color));
+    return string;
+}
+
+DEFUN ("x-get-border-color", Fx_get_border_color,
+       Sx_get_border_color, 0, 0, "",
+       "Returns the color of the border, as a string.")
+()
+{
+    Lisp_Object string;
+    string = make_string(brdr_color, strlen (brdr_color));
+    return string;
+}
+
+DEFUN ("x-get-cursor-color", Fx_get_cursor_color,
+       Sx_get_cursor_color, 0, 0, "",
+       "Returns the color of the cursor, as a string.")
+()
+{
+    Lisp_Object string;
+    string = make_string(curs_color, strlen (curs_color));
+    return string;
+}
+
+DEFUN ("x-get-mouse-color", Fx_get_mouse_color,
+       Sx_get_mouse_color, 0, 0, "",
+       "Returns the color of the mouse cursor, as a string.")
+()
+{
+    Lisp_Object string;
+    string = make_string(mous_color, strlen (mous_color));
+    return string;
+}
+
+DEFUN ("x-get-default", Fx_get_default, Sx_get_default, 1, 1,
+       "sGet X default name:  ",
+       "Get X default ATTRIBUTE from the system.  Returns nil if\n\
+attribute does not exist.")
+(arg)
+Lisp_Object arg;
+{
+    char *default_name, *value;
+    Lisp_Object return_string;
+    extern char *malloc(), strcpy();
+    check_xterm ();
+    CHECK_STRING (arg,1);
+    default_name = (char *) xmalloc (XSTRING (arg) -> size + 1);
+    if (default_name == 0)
+      {
+	  return Qnil;
+      }
+    else
+      {
+	  bcopy (XSTRING (arg) -> data, default_name,
+		 XSTRING (arg) -> size + 1);
+	  value = XGetDefault("emacs", default_name);
+	  if (value == 0)
+	    value = XGetDefault("", default_name);
+	  return make_string (value, value ? strlen (value) : 0);
+      }
+}    
+
+DEFUN ("x-set-icon", Fx_set_icon, Sx_set_icon, 1, 1, "P",
+  "Set type of icon used by X for Emacs's window.\n\
+ARG non-nil means use kitchen-sink icon;\n\
+nil means use generic window manager icon.")
+  (arg)
+     Lisp_Object arg;
+{
+  check_xterm ();
+  if (NULL (arg))
+    XTextIcon ();
+  else
+    XBitmapIcon ();
+  return arg;
+}
+
+DEFUN ("x-set-font", Fx_set_font, Sx_set_font, 1, 1, "sFont Name: ",
+      "At initialization sets the font to be used for the X window.")
+  (arg)
+     Lisp_Object arg;
+{
+  register char *newfontname;
+  extern char *XXcurrentfont;
+	
+  CHECK_STRING (arg, 1);
+  check_xterm ();
+
+  newfontname = (char *) xmalloc (XSTRING (arg)->size + 1);
+  bcopy (XSTRING (arg)->data, newfontname, XSTRING (arg)->size + 1);
+  if (!XNewFont (newfontname))
+    {
+      free (XXcurrentfont);
+      XXcurrentfont = newfontname;
+      return Qt;
+    }
+  else
+    {
+      error ("Font %s is not defined", newfontname);
+      free (newfontname);
+    }
+
+  return Qnil;
+}
+
+DEFUN ("x-set-window-edges", Fx_set_window_edges, Sx_set_window_edges, 4, 4,
+  "nNumber of Columns: \nnNumber of Rows: \nnX Offset in Pixels: \n\
+nY Offset in Pixels: ",
+  "Sets X window size/position: size COLS by ROWS, positions XOFF and YOFF.\n\
+To get \"minus zero\" for XOFF or YOFF, supply -1.")
+  (cols, rows, xoffset, yoffset)
+     Lisp_Object rows, cols, xoffset, yoffset;
+{
+  CHECK_NUMBER (rows, 1);
+  CHECK_NUMBER (cols, 2);
+  CHECK_NUMBER (xoffset, 3);
+  CHECK_NUMBER (yoffset, 4);
+  check_xterm ();
+
+  x_edges_specified = 1;
+  if (XINT (rows) != screen_width || XINT (cols) != screen_height) 
+    {
+      XSetWindowSize (XINT (rows), XINT (cols));
+    }
+  XSetOffset (XINT (xoffset), XINT (yoffset));
+  XFlush ();
+  return Qt;
+}
+
+DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
+  Scoordinates_in_window_p, 2, 2,
+  "xSpecify coordinate pair: \nXExpression which evals to window: ",
+  "Return non-nil if POSITIONS (a list, (SCREEN-X SCREEN-Y)) is in WINDOW.\n\
+Returned value is list of positions expressed\n\
+relative to window upper left corner.")
+  (coordinate, window)
+     register Lisp_Object coordinate, window;
+{
+  register Lisp_Object xcoord, ycoord;
+	
+  if (!LISTP  (coordinate)) wrong_type_argument (Qlistp, coordinate);
+  CHECK_WINDOW (window, 2);
+  xcoord = Fcar (coordinate);
+  ycoord = Fcar (Fcdr (coordinate));
+  CHECK_NUMBER (xcoord, 0);
+  CHECK_NUMBER (ycoord, 1);
+  if ((XINT (xcoord) < XINT (XWINDOW (window)->left)) ||
+      (XINT (xcoord) >= (XINT (XWINDOW (window)->left) +
+			 XINT (XWINDOW (window)->width))))
+    {
+      return Qnil;
+    } 
+  XFASTINT (xcoord) -= XFASTINT (XWINDOW (window)->left);
+  if (XINT (ycoord) == (screen_height - 1))
+    return Qnil;
+  if ((XINT (ycoord) < XINT (XWINDOW (window)->top)) ||
+      (XINT (ycoord) >= (XINT (XWINDOW (window)->top) +
+			 XINT (XWINDOW (window)->height)) - 1))
+    {
+      return Qnil;
+    }
+  XFASTINT (ycoord) -= XFASTINT (XWINDOW (window)->top);
+  return (Fcons (xcoord, Fcons (ycoord, Qnil)));
+}
+
+DEFUN ("x-mouse-events", Fx_mouse_events, Sx_mouse_events, 0, 0, 0,
+  "Return number of pending mouse events from X window system.")
+  ()
+{
+  register Lisp_Object tem;
+  register int windex, rindex, mindex;
+
+  check_xterm ();
+  windex = Xxrepbuffer.windex;
+  rindex = Xxrepbuffer.rindex;
+  mindex = Xxrepbuffer.mindex;
+
+  if (windex >= rindex) 
+    {
+      XSET (tem, Lisp_Int, windex - rindex);
+    }
+  else
+    {
+      XSET (tem, Lisp_Int, mindex + 1 - (rindex - windex));
+    }
+  return tem;
+}
+
+DEFUN ("x-proc-mouse-event", Fx_proc_mouse_event, Sx_proc_mouse_event,
+  0, 0, 0,
+  "Pulls a mouse event out of the mouse event buffer and dispatches\n\
+the appropriate function to act upon this event.")
+  ()
+{
+  XButtonEvent xrep;
+  extern FontInfo *fontinfo;
+  register Lisp_Object Mouse_Cmd;
+  register char com_letter;
+  register char key_mask;
+  register Lisp_Object tempx;
+  register Lisp_Object tempy;
+  extern Lisp_Object get_keyelt ();
+
+  check_xterm ();
+  if (unloadxrepbuffer (&xrep, &Xxrepbuffer) == 0) 
+    {
+      com_letter = xrep.detail & 3;
+      key_mask = (xrep.detail >> 8) & 0xf0;
+      com_letter |= key_mask;
+      XSET (tempx, Lisp_Int, xrep.x/fontinfo->width);
+      XSET (tempy, Lisp_Int, xrep.y/fontinfo->height);
+      Vx_mouse_pos = Fcons (tempx, Fcons (tempy, Qnil));
+      Mouse_Cmd = get_keyelt (access_keymap (MouseMap, com_letter));
+      if (NULL (Mouse_Cmd)) 
+	{
+	  Ding ();
+	  Vx_mouse_pos = Qnil;
+	}
+      else
+	{
+	  return (call1 (Mouse_Cmd, Vx_mouse_pos));
+	}
+    }
+  return Qnil;
+}
+
+DEFUN ("x-get-mouse-event", Fx_get_mouse_event, Sx_get_mouse_event,
+  1, 1, 0,
+  "Get next mouse event out of mouse event buffer (com-letter (x y)).\n\
+ARG non-nil means return nil immediately if no pending event;\n\
+otherwise, wait for an event.")
+  (arg)
+     Lisp_Object arg;
+{
+  XButtonEvent xrep;
+  extern FontInfo *fontinfo;
+  register Lisp_Object Mouse_Cmd;
+  register char com_letter;
+  register char key_mask;
+
+  register Lisp_Object tempx;
+  register Lisp_Object tempy;
+  extern Lisp_Object get_keyelt ();
+
+  check_xterm ();
+
+  if (NULL (arg))
+    while (Xxrepbuffer.windex == Xxrepbuffer.rindex);
+/*** ??? Surely you don't mean to busy wait??? */
+  if (unloadxrepbuffer (&xrep, &Xxrepbuffer) == 0) 
+    {
+      com_letter = *((char *)&xrep.detail);
+      com_letter &= 3;
+      key_mask = *((char *)&xrep.detail + 1);
+      key_mask &= 0xf0;
+      com_letter |= key_mask;
+      XSET (tempx, Lisp_Int, xrep.x/fontinfo->width);
+      XSET (tempy, Lisp_Int, xrep.y/fontinfo->height);
+      Vx_mouse_pos = Fcons (tempx, Fcons (tempy, Qnil));
+      return (Fcons (com_letter, Fcons (Vx_mouse_pos, Qnil)));
+    }
+  return Qnil;
+}
+
+DEFUN ("x-set-keyboard-enable", Fx_set_keyboard_enable,
+  Sx_set_keyboard_enable, 1, 1, 0,
+  "In the X window system, set the flag that permite keyboard input.\n\
+Permit input if ARG is non-nil.")
+  (arg)
+     Lisp_Object arg;
+{
+  extern Window XXwindow;
+  check_xterm ();
+
+  XSelectInput (XXwindow,
+		ExposeWindow | ButtonPressed | ExposeRegion | ExposeCopy
+		| (!NULL (arg) ? KeyPressed : 0));
+  return arg;
+}
+
+DEFUN ("x-set-mouse-inform-flag", Fx_set_mouse_inform_flag,
+  Sx_set_mouse_inform_flag, 1, 1, 0,
+  "Set inform-of-mouse-events flag in X window system on if ARG is non-nil.")
+  (arg)
+     Lisp_Object arg;
+{
+  extern int informflag;
+  informflag = !NULL (arg);
+  return arg;
+}
+
+DEFUN ("x-store-cut-buffer", Fx_store_cut_buffer, Sx_store_cut_buffer,
+  1, 1, "sSend string to X:",
+  "Store contents of STRING into the cut buffer of the X window system.")
+  (string)
+     register Lisp_Object string;
+{
+  CHECK_STRING (string, 1);
+  check_xterm ();
+
+  XStoreBytes (XSTRING (string)->data, XSTRING (string)->size);
+
+  return Qnil;
+}
+
+DEFUN ("x-get-cut-buffer", Fx_get_cut_buffer, Sx_get_cut_buffer, 0, 0, 0,
+  "Return contents of cut buffer of the X window system, as a string.")
+  ()
+{
+  int len;
+  register Lisp_Object string;
+  register int (*func) ();
+  register char *d;
+
+  func = (int (*)()) (signal (SIGIO, SIG_IGN));
+  d = XFetchBytes (&len);
+  string = make_string (d, len);
+  signal (SIGIO, func);
+  return string;
+}
+
+DEFUN ("x-rubber-band", Fx_rubber_band, Sx_rubber_band, 0, 0, 0,
+  "Ask user to specify Emacs window position and size with mouse.\n\
+This is done automatically if the data has not been specified\n\
+when Emacs needs the window to be displayed.")
+  ()
+{
+  int x, y, width, height;
+  extern int XXborder;
+  extern int PendingExposure;
+  extern char *default_window;
+  register int (*handle) ();
+  x_edges_specified = 1;
+
+  check_xterm ();
+  handle = signal (SIGIO, SIG_IGN);
+  window_fetch (fontinfo->id, &x, &y, &width, &height, "", default_window,
+		XXborder, "Gnuemacs");
+  (void) signal (SIGIO, handle);
+  XSetWindowSize (height, width);
+  XSetOffset (x, y);
+  XFlush();
+  return Qnil;
+}
+
+DEFUN ("x-create-x-window", Fx_create_x_window, Sx_create_x_window,
+       1, 1, 0,
+       "Create window for gnuemacs from a valid GEOMETRY specification.")
+(arg)
+Lisp_Object arg;
+{
+  int x, y, width, height;
+  extern int XXborder;
+  extern int PendingExposure;
+  char *geometry;
+  register int (*handle) ();
+  x_edges_specified = 1;
+
+  check_xterm ();
+  CHECK_STRING(arg, 1);
+  geometry= (char *) xmalloc (XSTRING (arg)->size + 1);
+  bcopy (XSTRING (arg)->data, geometry, XSTRING (arg)->size + 1);
+  handle = signal (SIGIO, SIG_IGN);
+  window_fetch (fontinfo->id, &x, &y, &width, &height, geometry,
+		default_window,	XXborder, "Gnuemacs");
+  (void) signal (SIGIO, handle);
+  XSetWindowSize (height, width);
+/*  XSetWindowSize ((height - (2 * XXborder))/fontinfo -> height,
+    (width - (2 * XXborder))/fontinfo -> width);*/
+  XSetOffset (x, y);
+  XMapWindow (XXwindow);
+  XFlush();
+  return Qnil;
+}
+
+DEFUN ("x-set-border-width", Fx_set_border_width, Sx_set_border_width,
+  1, 1, 0,
+  "Set width of border to WIDTH, in the X window system.\n\
+Works only before the window has been mapped.")
+  (borderwidth)
+     register Lisp_Object borderwidth;
+{
+  extern int WindowMapped;
+  extern int XXborder;
+  WindowInfo WinInfo;
+  extern Window XXwindow;
+  extern FontInfo *fontinfo;
+  extern Cursor EmacsCursor;
+  extern char iconidentity[];
+  register int (*func) ();
+  extern int CurHL;
+  Window tempwindow;
+  extern int pixelwidth, pixelheight;
+  register int temppixelwidth;
+  register int temppixelheight;
+  register int tempx;
+  register int tempy;
+  extern int XXxoffset, XXyoffset;
+  extern int XXpid;
+  Pixmap temp_brdr, temp_back;
+
+  CHECK_NUMBER (borderwidth, 1);
+
+  check_xterm ();
+  
+  if (XINT (borderwidth) < 0) XSETINT (borderwidth, 0);
+  
+  temppixelwidth = screen_width * fontinfo->width;
+  temppixelheight = screen_height * fontinfo->height;
+  func = signal (SIGIO, SIG_IGN);
+  XQueryWindow (XXwindow, &WinInfo);
+  tempx = WinInfo.x;
+  tempy = WinInfo.y;
+  if (strcmp (brdr_color, "gray") == 0)
+    temp_brdr = XMakePixmap ((Bitmap) XStoreBitmap (16, 16, gray_bits),
+			     BlackPixel, WhitePixel);
+  else
+    temp_brdr = XMakeTile(brdr);
+  temp_back = XMakeTile(back);
+  tempwindow = XCreateWindow (RootWindow,
+			      tempx /* Absolute horizontal offset */,
+			      tempy /* Absolute Vertical offset */,
+			      temppixelwidth, temppixelheight,
+			      XINT (borderwidth),
+			      temp_brdr, temp_back);
+  if (tempwindow) 
+    {
+      XDestroyWindow (XXwindow);
+      XXwindow = tempwindow;
+      pixelwidth = temppixelwidth;
+      pixelheight = temppixelheight;
+      XXborder = XINT (borderwidth);
+      XSelectInput (XXwindow, NoEvent);
+      XSetResizeHint (XXwindow, fontinfo->width * 10, fontinfo->height *5, 
+		      fontinfo->width, fontinfo->height);
+      XStoreName (XXwindow, &iconidentity[0]);
+      XDefineCursor (XXwindow, EmacsCursor);
+      XFreePixmap(temp_brdr);
+      XFreePixmap(temp_back);
+      (void)signal (SIGIO, func);
+      if (QLength () > 0)
+	{
+	  kill (XXpid, SIGIO);
+	}
+      if (WindowMapped)
+	{
+	  XMapWindow (XXwindow);
+	  XSelectInput (XXwindow, KeyPressed | ExposeWindow |
+			ButtonPressed | ExposeRegion |
+			  ExposeCopy);
+	  ++screen_garbaged;
+	  XFlush ();
+	}
+      return Qt;
+    }
+  else
+    {
+      (void) signal (SIGIO, func);
+      if (QLength () > 0)
+	{
+	  kill (XXpid, SIGIO);
+	}
+      message ("Could not recreate window.");
+      return Qnil;
+    }
+}
+
+jmp_buf dispenv;
+Display *OldDisplay;
+FontInfo *OldFontInfo;
+Window OldWindow;
+
+XRestoreDisplay ()
+{
+  longjmp (dispenv, "Unable to access display (probably)");
+}
+
+DEFUN ("x-change-display", Fx_change_display, Sx_change_display, 1, 1,
+  "sNew display name: ", 
+  "This function takes one argument, the display where you wish to\n\
+continue your editing session.  Your current window will be unmapped and\n\
+the current display will be closed.  The new X display will be opened and\n\
+the rubber-band outline of the new window will appear on the new X display.\n\
+This function does not look at your .Xdefaults file, so you should use the\n\
+function x-new-display instead.")
+  (new_display)
+     register Lisp_Object new_display;
+{
+  extern Cursor EmacsCursor;
+  Cursor OldEmacsCursor;
+  register int (*sigfunc) (), (*pipefunc) ();
+  register char *newdisplayname = 0;
+  extern char iconidentity[];
+  extern Display *XXdisplay;
+  extern Window XXwindow;
+  extern Window XXIconWindow;
+  extern int IconWindow;
+  extern Bitmap XXIconMask;
+  extern int pixelwidth, pixelheight, XXborder, CurHL;
+  extern FontInfo *fontinfo;
+  extern int bitblt, CursorExists, VisibleX, VisibleY;
+  extern WindowInfo rootwindowinfo;
+  extern char MouseCursor[], MouseMask[];
+  int old_fcntl_flags, old_fcntl_owner;
+  int x, y, width, height;
+  int temp_icon;
+  Pixmap temp_brdr, temp_back;
+  register char *XXerrorcode;
+  extern int XXxoffset, XXyoffset;	
+
+  CHECK_STRING (new_display, 1);
+  check_xterm ();
+
+/*  newdisplayname = xmalloc (XSTRING (new_display)->size + 1); */
+/*  bcopy (XSTRING (new_display)->data, newdisplayname, */
+/*	 XSTRING (new_display)->size + 1);  */
+  /* Since this was freed at the end, why not just use the original? */
+  newdisplayname = (char *) XSTRING (new_display)->data;
+  sigfunc = signal (SIGIO, SIG_IGN);
+  XIOErrorHandler(XRestoreDisplay);
+   if (XXerrorcode = (char *) setjmp (dispenv))
+     {
+ /*       free (&newdisplayname[0]); */
+       if (fontinfo)
+	 XCloseFont (fontinfo);
+       if (XXwindow)
+	 XDestroyWindow (XXwindow);
+       if (XXdisplay)
+	 XCloseDisplay (XXdisplay);
+       XXdisplay = OldDisplay;
+       fontinfo = OldFontInfo;
+       XXwindow = OldWindow;
+       EmacsCursor = OldEmacsCursor;
+       XIOErrorHandler (0);
+       XSetDisplay (XXdisplay);
+       (void)signal (SIGIO, sigfunc);
+       if (QLength () > 0)
+	 {
+	   kill (XXpid, SIGIO);
+	 }
+       error ("Display change problem: %s", XXerrorcode);
+     }
+   else
+     {
+       OldEmacsCursor = EmacsCursor;
+       OldDisplay = XXdisplay;
+       OldFontInfo = fontinfo;
+       OldWindow = XXwindow;
+       XXwindow = 0;
+       fontinfo = 0;
+       XXdisplay = 0;
+     }
+   XXdisplay = XOpenDisplay (newdisplayname);
+   if (!XXdisplay)
+     {
+       longjmp (dispenv, "Probably nonexistant display");
+     }
+   XQueryWindow (RootWindow, &rootwindowinfo);
+   fontinfo = XOpenFont (XXcurrentfont);
+   if (!fontinfo)
+     {
+       longjmp (dispenv, "Bad font");
+     }
+   /* pixelwidth and pixelheight are correct*/
+   XXwindow = XCreateWindow (RootWindow,
+			     XXxoffset,
+			     XXyoffset,
+			     pixelwidth, pixelheight,
+			     XXborder, BlackPixmap, WhitePixmap);
+   if (!XXwindow)
+     {
+       longjmp (dispenv, "Could not create window");
+     }
+   fore = BlackPixel;
+   back = WhitePixel;
+   brdr = BlackPixel;
+   mous = BlackPixel;
+   curs = BlackPixel;
+
+   fore_color = "black";
+   back_color = "white";
+   brdr_color = "black";
+   mous_color = "black";
+   curs_color = "black";
+
+   XSelectInput (XXwindow, NoEvent);
+   EmacsCursor = XCreateCursor (16, 16, MouseCursor, MouseMask,
+				0, 0, mous, back, GXcopy);
+   XDefineCursor (XXwindow, EmacsCursor);
+
+   XSetResizeHint (XXwindow, fontinfo->width * 10, fontinfo->height * 5, 
+		  fontinfo->width, fontinfo->height);
+   XStoreName (XXwindow, iconidentity);
+/*  WindowMapped = 0;*/
+  x_edges_specified = 0;
+  bitblt = 0;
+  CursorExists = 0;
+  VisibleX = 0;
+  VisibleY = 0;
+  XSetDisplay (XXdisplay);
+/*  XQueryWindow (RootWindow, &rootwindowinfo);*/
+/*  if (WindowMapped)
+    {*/
+  WindowMapped = 0;
+  XPopUpWindow ();
+/*  }*/
+  WindowMapped = 1;
+  XXIconWindow = XCreateWindow (RootWindow, 0, 0, sink_width, sink_height,
+				2, WhitePixmap, BlackPixmap);
+  XXIconMask = XStoreBitmap(sink_mask_width, sink_mask_height, sink_mask_bits);
+  XSetDisplay (OldDisplay);
+  XCloseFont (OldFontInfo);
+  XFreeCursor (OldEmacsCursor);
+  XDestroyWindow (OldWindow);
+  XSetDisplay (XXdisplay);
+  XCloseDisplay (OldDisplay);
+  temp_icon = IconWindow;
+  XBitmapIcon;
+  XTextIcon;
+  if (temp_icon)
+    {
+	IconWindow = 0;
+	XBitmapIcon;
+    }
+  XErrorHandler (0);
+  dup2 (dpyno (), 0);
+  close (dpyno ());
+  dpyno () = 0;		/* Looks a little strange? */
+  /* check the def of the */
+  /* macro, it is a genuine */
+  /* lvalue */
+  old_fcntl_flags = fcntl (0, F_GETFL, 0);
+  fcntl (0, F_SETFL, old_fcntl_flags | FASYNC);
+  old_fcntl_owner = fcntl (0, F_GETOWN, 0);
+  fcntl (0, F_SETOWN, getpid ());
+  (void)signal (SIGIO, sigfunc);
+  if (QLength () > 0)
+    {
+      kill (XXpid, SIGIO);
+    }
+/*  free (newdisplayname); */
+/*  x_edges_specified = 0;*/
+  ++screen_garbaged;
+  Fredraw_display();
+  return Qt;
+}
+
+/*
+   Grabs mouse, outlines a window, etc.
+   if left button pressed, sizes a wd x hd window (in characters)
+   if right button pressed, sizes wd x what will fit window (in characters)
+   if middle button pressed, allows user to size window in font increments
+   	(+ border * 2 for inner border);
+   While sizing, dimensions of window are displayed in upper left of root.
+   str is also displayed there.
+   In all cases, x and y are the desired coordinates for the upper lefthand
+   	corner, *width = width desired, *height = height desired
+	(min for both is 1 font char).
+
+	*/
+/*
+  This routine is a total crock.  It makes a window using XCreateTerm
+  purely for return value, destroying the temporary window created in
+  the process.  If XCreateTerm were broken into smaller, more easily
+  digestible pieces, it would be useful.  As such, the constraints of
+  time, emacs, and X conventions force me into this crock. --rlk
+  */
+
+window_fetch(font, x, y, width, height, geo, deflt, border, str)
+Font font;
+int *x, *y, *width, *height;
+char *geo, *deflt;
+int border;
+char *str;
+{
+  extern int WindowMapped;
+  extern int XXborder;
+  extern Window XXwindow;
+  extern FontInfo *fontinfo;
+  extern Cursor EmacsCursor;
+  OpaqueFrame frame;
+  extern char iconidentity[];
+  register int (*func) ();
+  Window tempwindow;
+  WindowInfo WinInfo;
+  extern int pixelwidth, pixelheight;
+  register int temppixelwidth;
+  register int temppixelheight;
+  extern int XXxoffset, XXyoffset;
+  extern int XXpid;
+  Pixmap temp_brdr, temp_back;
+
+  func = signal (SIGIO, SIG_IGN);
+  temp_brdr = XMakeTile(brdr);
+  temp_back = XMakeTile(back);
+  frame.bdrwidth = border;
+  frame.border = XMakeTile (brdr);
+  frame.background = XMakeTile (back);
+  tempwindow = XCreateTerm(str, "emacs", geo, deflt, &frame, 10, 5, 0, 0,
+			   width, height, fontinfo, fontinfo->width,
+			   fontinfo->height);
+  if (tempwindow) 
+    {
+      XDestroyWindow (XXwindow);
+      XXwindow = tempwindow;
+      XSelectInput (XXwindow, NoEvent);
+      XSetResizeHint (XXwindow, fontinfo->width * 10, fontinfo->height *5, 
+		      fontinfo->width, fontinfo->height);
+      XStoreName (XXwindow, &iconidentity[0]);
+      XDefineCursor (XXwindow, EmacsCursor);
+      XQueryWindow (XXwindow, &WinInfo);
+      *x = WinInfo.x;
+      *y = WinInfo.y;
+      XFreePixmap(temp_brdr);
+      XFreePixmap(temp_back);
+      (void)signal (SIGIO, func);
+      if (QLength () > 0)
+	{
+	  kill (XXpid, SIGIO);
+	}
+      if (WindowMapped)
+	{
+	  XMapWindow (XXwindow);
+	  XSelectInput (XXwindow, KeyPressed | ExposeWindow |
+			ButtonPressed | ExposeRegion |
+			  ExposeCopy);
+	  ++screen_garbaged;
+	  XFlush ();
+	}
+      return Qt;
+    }
+  else
+    {
+      (void) signal (SIGIO, func);
+      if (QLength () > 0)
+	{
+	  kill (XXpid, SIGIO);
+	}
+      message ("Could not recreate window.");
+      return Qnil;
+    }
+}
+
+setxterm ()
+{
+  Vxterm = Qt;
+}
+
+XRedrawDisplay()
+{
+    Fredraw_display();
+}
+
+XAutoSave()
+{
+  Fdo_auto_save();
+}
+
+
+syms_of_xfns ()
+{
+  x_edges_specified = 0;
+
+  DefLispVar("xterm", &Vxterm,
+	     "True if using xterm, nil otherwise.");
+  Vxterm = Qnil;
+  DefLispVar("x-mouse-pos", &Vx_mouse_pos,
+     "Current x-y position of mouse by row, column as specified by font.");
+  Vx_mouse_pos = Qnil;
+
+  defsubr (&Sx_pop_up_window);
+  defsubr (&Sx_set_bell);
+  defsubr (&Sx_flip_color);
+  defsubr (&Sx_set_icon);
+  defsubr (&Sx_set_font);
+  defsubr (&Sx_set_window_edges);
+  defsubr (&Scoordinates_in_window_p);
+  defsubr (&Sx_mouse_events);
+  defsubr (&Sx_proc_mouse_event);
+  defsubr (&Sx_get_mouse_event);
+  defsubr (&Sx_set_keyboard_enable);
+  defsubr (&Sx_set_mouse_inform_flag);
+  defsubr (&Sx_store_cut_buffer);
+  defsubr (&Sx_get_cut_buffer);
+  defsubr (&Sx_rubber_band);
+  defsubr (&Sx_create_x_window);
+  defsubr (&Sx_set_border_width);
+  defsubr (&Sx_change_display);
+  defsubr (&Sx_set_foreground_color);
+  defsubr (&Sx_set_background_color);
+  defsubr (&Sx_set_border_color);
+  defsubr (&Sx_set_cursor_color);
+  defsubr (&Sx_set_mouse_color);
+  defsubr (&Sx_get_foreground_color);
+  defsubr (&Sx_get_background_color);
+  defsubr (&Sx_get_border_color);
+  defsubr (&Sx_get_cursor_color);
+  defsubr (&Sx_get_mouse_color);
+  defsubr (&Sx_color_p);
+  defsubr (&Sx_get_default);
+}