comparison src/xterm.c @ 9654:41681efe1086

Use FRAME_X_DISPLAY instead of x_current_display and XDISPLAY. (x_make_frame_visible, x_make_frame_invisible): Pass a frame ptr to x_sync. (x_term_init): Init all the components of dpyinfo. (x_display_info_for_display): New function. (x_*_mod_mask): Variables deleted. (x_x_to_emacs_modifiers, x_emacs_to_x_modifiers): New arg dpyinfo; all callers changed. Store the masks in that structure. (icon_bitmap): Variable deleted. (x_bitmap_icon): Use icon_bitmap_id in x_display_info. (icon_font_info): Variable deleted. (x_term_init): Set up `connection' field. (x_find_modifier_meanings): Arg is now struct x_display_info *. (x_term_init): Return an x_display_info *. Store all the data in it, including X atoms and xrdb. Put the x_display_info structure on x_display_list. Pass name as Lisp_Object. (the_x_screen): Variable moved here. (syms_of_xterm): Staticpro parts of the_x_screen. (windowinfo): Variable deleted. (Xatom_*): Variables deleted. (x_iconify_frame, XTread_socket): Get atoms from the x_display_info, (XTread_socket): Don't update Vmouse_depressed. (x_mouse_grabbed): Variable deleted. (note_mouse_highlight): Use grabbed field instead. (XTmouse_position, XTread_socket): Likewise. (x_calc_absolute_position, x_wm_set_size_hint): Get screen height, width from the x_display_info structure.

9653:cfc5e15e0baf

#if defined (SIGIO) && defined (FIONREAD)
int BLOCK_INPUT_mask;
#endif /* ! defined (SIGIO) && defined (FIONREAD) */

/* The id of a bitmap used for icon windows, in frames
   for which no specific bitmap was specified.
   This is 0 if we have not yet had a need to create the bitmap.  */

static int icon_bitmap;

/* Font used for text icons.  */

static FONT_TYPE *icon_font_info;

/* Stuff for dealing with the main icon title. */

extern Lisp_Object Vcommand_line_args, Vsystem_name;
char *x_id_name;

/* Initial values of argv and argc.  */
extern char **initial_argv;
extern int initial_argc;

/* This is the X connection that we are using.  */

Display *x_current_display;

/* The cursor to use for vertical scroll bars on x_current_display.  */
static Cursor x_vertical_scroll_bar_cursor;

/* Frame being updated by update_frame.  This is declared in term.c.

   If the last X motion event didn't occur in a scroll bar, we set this
   to Qnil, to tell XTmouse_position to return an ordinary motion event.  */
static Lisp_Object last_mouse_scroll_bar;

/* Record which buttons are currently pressed.  */
unsigned int x_mouse_grabbed;

/* This is a hack.  We would really prefer that XTmouse_position would
   return the time associated with the position it returns, but there
   doesn't seem to be any way to wrest the timestamp from the server
   along with the position query.  So, we just keep track of the time
   of the last movement we received, and return that in hopes that

static int volatile input_signal_count;
#else
static int input_signal_count;
#endif

/* `t' if a mouse button is depressed. */

extern Lisp_Object Vmouse_depressed;

/* Tells if a window manager is present or not. */

extern Lisp_Object Vx_no_window_manager;

/* Timestamp that we requested selection data was made. */

extern Lisp_Object Qface, Qmouse_face;

static int x_noop_count;


/* From time to time we get info on an Emacs window, here.  */

static WINDOWINFO_TYPE windowinfo;

extern int errno;

/* A mask of extra modifier bits to put into every keyboard char.  */
extern int extra_keyboard_modifiers;

extern Display *XOpenDisplay ();
extern Window XCreateWindow ();

extern Cursor XCreateCursor ();
extern FONT_TYPE *XOpenFont ();

static void flashback ();
static void redraw_previous_char ();
static void redraw_following_char ();
static unsigned int x_x_to_emacs_modifiers ();

static void do_line_dance ();

void dumpborder ();
static int XTcursor_to ();
static int XTclear_end_of_line ();


/* Starting and ending updates.

   These hooks are called by update_frame at the beginning and end
   of a frame update.  We record in `updating_frame' the identity

     for that case.  window_end_valid isn't set up yet.  */
  if (f == mouse_face_mouse_frame)
    note_mouse_highlight (f, mouse_face_mouse_x, mouse_face_mouse_y);
#endif

  XFlushQueue ();
  UNBLOCK_INPUT;
}

/* This is called after a redisplay on frame F.  */

  if (updating_frame == 0)
    {
      BLOCK_INPUT;
      x_display_cursor (selected_frame, 1);
      XFlushQueue ();
      UNBLOCK_INPUT;
    }
}

/* Display a sequence of N glyphs found at GP.

      /* Now output this run of chars, with the font and pixel values
	 determined by the face code CF.  */
      {
	struct face *face = FRAME_DEFAULT_FACE (f);
	FONT_TYPE *font = FACE_FONT (face);
	GC gc = FACE_GC (face);
	int stippled = 0;

	/* HL = 3 means use a mouse face previously chosen.  */
	if (hl == 3)

		  }
		xgcv.font = face->font->fid;
		xgcv.graphics_exposures = 0;
		mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
		if (scratch_cursor_gc)
		  XChangeGC (x_current_display, scratch_cursor_gc, mask, &xgcv);
		else
		  scratch_cursor_gc
		    = XCreateGC (x_current_display, window, mask, &xgcv);
		gc = scratch_cursor_gc;
#if 0
/* If this code is restored, it must also reset to the default stipple
   if necessary. */
		if (face->stipple && face->stipple != FACE_DEFAULT)
		  XSetStipple (x_current_display, gc, face->stipple);
#endif
	      }
	  }

	if ((int) font == FACE_DEFAULT)
	  font = f->display.x->font;

	if (just_foreground)
	  XDrawString (x_current_display, window, gc,
		       left, top + FONT_BASE (font), buf, len);
	else
	  {
	    if (stippled)
	      {
		/* Turn stipple on.  */
		XSetFillStyle (FRAME_X_DISPLAY (f), gc, FillOpaqueStippled);

		/* Draw stipple on background.  */
		XFillRectangle (x_current_display, window, gc,
				left, top,
				FONT_WIDTH (font) * len,
				FONT_HEIGHT (font));

		/* Turn stipple off.  */
		XSetFillStyle (FRAME_X_DISPLAY (f), gc, FillSolid);

		/* Draw the text, solidly, onto the stipple pattern.  */
		XDrawString (x_current_display, window, gc,
			     left, top + FONT_BASE (font), buf, len);
	      }
	    else
	      XDrawImageString (x_current_display, window, gc,
				left, top + FONT_BASE (font), buf, len);

	    /* Clear the rest of the line's height.  */
	    if (f->display.x->line_height != FONT_HEIGHT (font))
	      XClearArea (x_current_display, window, left,
			  top + FONT_HEIGHT (font),
			  FONT_WIDTH (font) * len,
			  /* This is how many pixels of height
			     we have to clear.  */
			  f->display.x->line_height - FONT_HEIGHT (font),

	  if (font->descent <= underline_position)
	    underline_position = font->descent - 1;

	  if (face->underline)
	    XFillRectangle (x_current_display, FRAME_X_WINDOW (f),
			    FACE_GC (face),
			    left, (top
				   + FONT_BASE (font)
				   + underline_position),
			    len * FONT_WIDTH (font), 1);

     struct frame *f;
     int left, top;
     register GLYPH *gp; /* Points to first GLYPH. */
     register int n;  /* Number of glyphs to display. */
     int hl;
     FONT_TYPE *font;
{
  register int len;
  Window window = FRAME_X_WINDOW (f);
  GC drawing_gc =   (hl == 2 ? f->display.x->cursor_gc
		             : (hl ? f->display.x->reverse_gc
				   : f->display.x->normal_gc));

  if (sizeof (GLYPH) == sizeof (XChar2b))
    XDrawImageString16 (x_current_display, window, drawing_gc,
			left, top + FONT_BASE (font), (XChar2b *) gp, n);
  else if (sizeof (GLYPH) == sizeof (unsigned char))
    XDrawImageString (x_current_display, window, drawing_gc,
		      left, top + FONT_BASE (font), (char *) gp, n);
  else
    /* What size of glyph ARE you using?  And does X have a function to
       draw them?  */
    abort ();

  if (curs_y == f->phys_cursor_y
      && curs_x <= f->phys_cursor_x
      && f->phys_cursor_x < first_unused)
    f->phys_cursor_x = -1;

  XClearArea (x_current_display, FRAME_X_WINDOW (f),
	      CHAR_TO_PIXEL_COL (f, curs_x),
	      CHAR_TO_PIXEL_ROW (f, curs_y),
	      FONT_WIDTH (f->display.x->font) * (first_unused - curs_x),
	      f->display.x->line_height, False);
#if 0

  curs_x = 0;			/* Nominal cursor position is top left.  */
  curs_y = 0;

  BLOCK_INPUT;

  XClear (FRAME_X_WINDOW (f));

  /* We have to clear the scroll bars, too.  If we have changed
     colors or something like that, then they should be notified.  */
  x_scroll_bar_clear (f);

  XFlushQueue ();
  UNBLOCK_INPUT;
}

#if 0
/* This currently does not work because FRAME_CURRENT_GLYPHS doesn't

  if (x > 0)
    {
      int start_x = x - 2;
      if (start_x < 0)
	start_x = 0;
      XClearArea (x_current_display, FRAME_X_WINDOW (f),
		  CHAR_TO_PIXEL_COL (f, x - 1),
		  CHAR_TO_PIXEL_ROW (f, y),
		  FONT_WIDTH (f->display.x->font),
		  f->display.x->line_height, False);

      && FRAME_CURRENT_GLYPHS (f)->glyphs[y][x] != SPACEGLYPH)
    {
      int end_x = x + 2;
      if (end_x > limit)
	end_x = limit;
      XClearArea (x_current_display, FRAME_X_WINDOW (f),
		  CHAR_TO_PIXEL_COL (f, x),
		  CHAR_TO_PIXEL_ROW (f, y),
		  FONT_WIDTH (f->display.x->font),
		  f->display.x->line_height, False);

      values.function = GXxor;
      values.foreground = (f->display.x->foreground_pixel
			   ^ f->display.x->background_pixel);

      gc = XCreateGC (x_current_display, FRAME_X_WINDOW (f),
		      GCFunction | GCForeground, &values);
    }

    {
      int width  = PIXEL_WIDTH  (f);
      int height = PIXEL_HEIGHT (f);

      XFillRectangle (x_current_display, FRAME_X_WINDOW (f), gc,
		      width/4, height/4, width/2, height/2);
      XFlush (x_current_display);

      {
	struct timeval wakeup, now;

	EMACS_GET_TIME (wakeup);

	    /* Try to wait that long--but we might wake up sooner.  */
	    select (0, 0, 0, 0, &timeout);
	  }
      }

      XFillRectangle (x_current_display, FRAME_X_WINDOW (f), gc,
		      width/4, height/4, width/2, height/2);
      XFreeGC (x_current_display, gc);
      XFlush (x_current_display);
    }
  }

  UNBLOCK_INPUT;
}

#endif


/* Make audible bell.  */

#define XRINGBELL XBell (x_current_display, 0)

XTring_bell ()
{
  if (x_current_display == 0)
    return;

#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
  if (visible_bell)
    XTflash (selected_frame);
  else
#endif
    {
      BLOCK_INPUT;
      XRINGBELL;
      XFlushQueue ();
      UNBLOCK_INPUT;
    }
}

/* Insert and delete character.

    if (line_dance[i] != -1 && (distance = line_dance[i]-i) > 0)
      {
	for (j = i; (j < ht && line_dance[j] != -1
		     && line_dance[j]-j == distance); ++j);
	/* Copy [i,j) upward from [i+distance,j+distance) */
	XCopyArea (x_current_display, FRAME_X_WINDOW (f),
		   FRAME_X_WINDOW (f), f->display.x->normal_gc,
		   intborder, CHAR_TO_PIXEL_ROW (f, i+distance),
		   f->width * FONT_WIDTH (f->display.x->font),
		   (j-i) * f->display.x->line_height,
		   intborder, CHAR_TO_PIXEL_ROW (f, i));

    if (line_dance[i] != -1 && (distance = line_dance[i]-i) < 0)
      {
	for (j = i; (--j >= 0 && line_dance[j] != -1
		     && line_dance[j]-j == distance););
	/* Copy (j,i] downward from (j+distance, i+distance] */
	XCopyArea (x_current_display, FRAME_X_WINDOW (f),
		   FRAME_X_WINDOW (f), f->display.x->normal_gc,
		   intborder, CHAR_TO_PIXEL_ROW (f, j+1+distance),
		   f->width * FONT_WIDTH (f->display.x->font),
		   (i-j) * f->display.x->line_height,
		   intborder, CHAR_TO_PIXEL_ROW (f, j+1));

  for (i = 0; i < ht; ++i)
    if (line_dance[i] == -1)
      {
	for (j = i; j < ht && line_dance[j] == -1; ++j);
	/* Clear [i,j) */
	XClearArea (x_current_display, FRAME_X_WINDOW (f),
		    intborder, CHAR_TO_PIXEL_ROW (f, i),
		    f->width * FONT_WIDTH (f->display.x->font),
		    (j-i) * f->display.x->line_height, False);
	i = j-1;
      }

  if (cursor_cleared)
    x_display_cursor (f, 1);
}

static void
frame_highlight (frame)
     struct frame *frame;
{
  /* We used to only do this if Vx_no_window_manager was non-nil, but
     the ICCCM (section 4.1.6) says that the window's border pixmap
     and border pixel are window attributes which are "private to the
     client", so we can always change it to whatever we want.  */
  BLOCK_INPUT;
  XSetWindowBorder (x_current_display, FRAME_X_WINDOW (frame),
		    frame->display.x->border_pixel);
  UNBLOCK_INPUT;
  x_display_cursor (frame, 1);
}

static void
frame_unhighlight (frame)
     struct frame *frame;
{
  /* We used to only do this if Vx_no_window_manager was non-nil, but
     the ICCCM (section 4.1.6) says that the window's border pixmap
     and border pixel are window attributes which are "private to the
     client", so we can always change it to whatever we want.  */
  BLOCK_INPUT;
  XSetWindowBorderPixmap (x_current_display, FRAME_X_WINDOW (frame),
			  frame->display.x->border_tile);
  UNBLOCK_INPUT;
  x_display_cursor (frame, 1);
}

static void XTframe_rehighlight ();

/* The focus has changed.  Update the frames as necessary to reflect

    }
}

/* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */

/* Which modifier keys are on which modifier bits?

   With each keystroke, X returns eight bits indicating which modifier
   keys were held down when the key was pressed.  The interpretation
   of the top five modifier bits depends on what keys are attached
   to them.  If the Meta_L and Meta_R keysyms are on mod5, then mod5
   is the meta bit.

   x_meta_mod_mask is a mask containing the bits used for the meta key.
   It may have more than one bit set, if more than one modifier bit
   has meta keys on it.  Basically, if EVENT is a KeyPress event,
   the meta key is pressed if (EVENT.state & x_meta_mod_mask) != 0.

   x_shift_lock_mask is LockMask if the XK_Shift_Lock keysym is on the
   lock modifier bit, or zero otherwise.  Non-alphabetic keys should
   only be affected by the lock modifier bit if XK_Shift_Lock is in
   use; XK_Caps_Lock should only affect alphabetic keys.  With this
   arrangement, the lock modifier should shift the character if
   (EVENT.state & x_shift_lock_mask) != 0.  */
static int x_meta_mod_mask, x_shift_lock_mask;

/* These are like x_meta_mod_mask, but for different modifiers.  */
static int x_alt_mod_mask, x_super_mod_mask, x_hyper_mod_mask;

/* Initialize mode_switch_bit and modifier_meaning.  */
static void
x_find_modifier_meanings ()
{
  int min_code, max_code;
  KeySym *syms;
  int syms_per_code;
  XModifierKeymap *mods;

  x_meta_mod_mask = 0;
  x_shift_lock_mask = 0;
  x_alt_mod_mask = 0;
  x_super_mod_mask = 0;
  x_hyper_mod_mask = 0;

#ifdef HAVE_X11R4
  XDisplayKeycodes (x_current_display, &min_code, &max_code);
#else
  min_code = x_current_display->min_keycode;
  max_code = x_current_display->max_keycode;
#endif

  syms = XGetKeyboardMapping (x_current_display,
			      min_code, max_code - min_code + 1,
			      &syms_per_code);
  mods = XGetModifierMapping (x_current_display);

  /* Scan the modifier table to see which modifier bits the Meta and
     Alt keysyms are on.  */
  {
    int row, col;	/* The row and column in the modifier table. */

		switch (sym)
		  {
		  case XK_Meta_L:
		  case XK_Meta_R:
		    x_meta_mod_mask |= (1 << row);
		    break;

		  case XK_Alt_L:
		  case XK_Alt_R:
		    x_alt_mod_mask |= (1 << row);
		    break;

		  case XK_Hyper_L:
		  case XK_Hyper_R:
		    x_hyper_mod_mask |= (1 << row);
		    break;

		  case XK_Super_L:
		  case XK_Super_R:
		    x_super_mod_mask |= (1 << row);
		    break;

		  case XK_Shift_Lock:
		    /* Ignore this if it's not on the lock modifier.  */
		    if ((1 << row) == LockMask)
		      x_shift_lock_mask = LockMask;
		    break;
		  }
	      }
	  }
	}
  }

  /* If we couldn't find any meta keys, accept any alt keys as meta keys.  */
  if (! x_meta_mod_mask)
    {
      x_meta_mod_mask = x_alt_mod_mask;
      x_alt_mod_mask = 0;
    }

  /* If some keys are both alt and meta,
     make them just meta, not alt.  */
  if (x_alt_mod_mask & x_meta_mod_mask)
    {
      x_alt_mod_mask &= ~x_meta_mod_mask;
    }

  XFree ((char *) syms);
  XFreeModifiermap (mods);
}

/* Convert between the modifier bits X uses and the modifier bits
   Emacs uses.  */
static unsigned int
x_x_to_emacs_modifiers (state)
     unsigned int state;
{
  return (  ((state & (ShiftMask | x_shift_lock_mask)) ? shift_modifier : 0)
	  | ((state & ControlMask)		       ? ctrl_modifier  : 0)
	  | ((state & x_meta_mod_mask)		       ? meta_modifier  : 0)
	  | ((state & x_alt_mod_mask)		       ? alt_modifier  : 0)
	  | ((state & x_super_mod_mask)		       ? super_modifier  : 0)
	  | ((state & x_hyper_mod_mask)		       ? hyper_modifier  : 0));
}

static unsigned int
x_emacs_to_x_modifiers (state)
     unsigned int state;
{
  return (  ((state & alt_modifier)		? x_alt_mod_mask   : 0)
	  | ((state & super_modifier)		? x_super_mod_mask : 0)
	  | ((state & hyper_modifier)		? x_hyper_mod_mask : 0)
	  | ((state & shift_modifier)		? ShiftMask        : 0)
	  | ((state & ctrl_modifier)		? ControlMask      : 0)
	  | ((state & meta_modifier)		? x_meta_mod_mask  : 0));
}

/* Mouse clicks and mouse movement.  Rah.  */

/* Given a pixel position (PIX_X, PIX_Y) on the frame F, return

  /* Make the event type no_event; we'll change that when we decide
     otherwise.  */
  result->kind = mouse_click;
  result->code = event->button - Button1;
  result->timestamp = event->time;
  result->modifiers = (x_x_to_emacs_modifiers (event->state)
		       | (event->type == ButtonRelease
			  ? up_modifier
			  : down_modifier));

  {

  /* Make the event type no_event; we'll change that when we decide
     otherwise.  */
  result->kind = mouse_click;
  XSETINT (result->code, event->button - Button1);
  result->timestamp = event->time;
  result->modifiers = (x_x_to_emacs_modifiers (event->state)
		       | (event->type == ButtonRelease
			  ? up_modifier
			  : down_modifier));

  XSETINT (result->x, event->x);

      return;
    }

  /* Find out which glyph the mouse is on.  */
  pixel_to_glyph_coords (f, x, y, &column, &row,
			 &new_glyph, x_mouse_grabbed);

  /* Which window is that in?  */
  window = window_from_coordinates (f, column, row, &portion);
  w = XWINDOW (window);

  curs_x = old_curs_x;
  curs_y = old_curs_y;

  /* Change the mouse cursor according to the value of HL.  */
  if (hl > 0)
    XDefineCursor (XDISPLAY FRAME_X_WINDOW (f), f->display.x->cross_cursor);
  else
    XDefineCursor (XDISPLAY FRAME_X_WINDOW (f), f->display.x->text_cursor);
}

/* Clear out the mouse-highlighted active region.
   Redraw it unhighlighted first.  */

   movement.  This also calls XQueryPointer, which will cause the
   server to give us another MotionNotify when the mouse moves
   again. */

static void
XTmouse_position (f, bar_window, part, x, y, time)
     FRAME_PTR *f;
     Lisp_Object *bar_window;
     enum scroll_bar_part *part;
     Lisp_Object *x, *y;
     unsigned long *time;
{
  FRAME_PTR f1;

  BLOCK_INPUT;

  if (! NILP (last_mouse_scroll_bar))
    x_scroll_bar_report_motion (f, bar_window, part, x, y, time);
  else
    {
      Window root;
      int root_x, root_y;

      mouse_moved = 0;
      last_mouse_scroll_bar = Qnil;

      /* Figure out which root window we're on.  */
      XQueryPointer (x_current_display,
		     DefaultRootWindow (x_current_display),

		     /* The root window which contains the pointer.  */
		     &root,

		     /* Trash which we can't trust if the pointer is on

	int win_x, win_y;
	int parent_x, parent_y;

	win = root;

	if (x_mouse_grabbed && last_mouse_frame
	    && FRAME_LIVE_P (last_mouse_frame))
	  {
	    /* If mouse was grabbed on a frame, give coords for that frame
	       even if the mouse is now outside it.  */
	    XTranslateCoordinates (x_current_display,

				   /* From-window, to-window.  */
				   root, FRAME_X_WINDOW (last_mouse_frame),

				   /* From-position, to-position.  */

	  }
	else
	  {
	    while (1)
	      {
		XTranslateCoordinates (x_current_display,

				       /* From-window, to-window.  */
				       root, win,

				       /* From-position, to-position.  */

	    int ignore1, ignore2;

	    /* Ok, we found a frame.  Store all the values.  */

	    pixel_to_glyph_coords (f1, win_x, win_y, &ignore1, &ignore2,
				   &last_mouse_glyph, x_mouse_grabbed);

	    *bar_window = Qnil;
	    *part = 0;
	    *f = f1;
	    XSETINT (*x, win_x);
	    XSETINT (*y, win_y);
	    *time = last_mouse_movement_time;
	  }
      }

static struct scroll_bar *
x_scroll_bar_create (window, top, left, width, height)
     struct window *window;
     int top, left, width, height;
{
  FRAME_PTR frame = XFRAME (WINDOW_FRAME (window));
  struct scroll_bar *bar =
    XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));

  BLOCK_INPUT;

  {
    XSetWindowAttributes a;
    unsigned long mask;
    a.background_pixel = frame->display.x->background_pixel;
    a.event_mask = (ButtonPressMask | ButtonReleaseMask
		    | ButtonMotionMask | PointerMotionHintMask
		    | ExposureMask);
    a.cursor = x_vertical_scroll_bar_cursor;

    XtSetArg (al[ac], XtNwidth, width); ac++;
    XtSetArg (al[ac], XtNheight, height); ac++;
    XtSetArg (al[ac], XtNborderWidth, 0); ac++;
    sb_widget = XtCreateManagedWidget ("box",
				       boxWidgetClass,
				       frame->display.x->edit_widget, al, ac);
    SET_SCROLL_BAR_X_WINDOW
      (bar, sb_widget->core.window);
#endif
    SET_SCROLL_BAR_X_WINDOW
      (bar,
       XCreateWindow (x_current_display, FRAME_X_WINDOW (frame),

		      /* Position and size of scroll bar.  */
		      left, top, width, height,

		      /* Border width, depth, class, and visual.  */

  XSETINT (bar->start, 0);
  XSETINT (bar->end, 0);
  bar->dragging = Qnil;

  /* Add bar to its frame's list of scroll bars.  */
  bar->next = FRAME_SCROLL_BARS (frame);
  bar->prev = Qnil;
  XSETVECTOR (FRAME_SCROLL_BARS (frame), bar);
  if (! NILP (bar->next))
    XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);

  XMapWindow (x_current_display, SCROLL_BAR_X_WINDOW (bar));

  UNBLOCK_INPUT;

  return bar;
}

     int start, end;
     int rebuild;
{
  int dragging = ! NILP (bar->dragging);
  Window w = SCROLL_BAR_X_WINDOW (bar);
  GC gc = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))->display.x->normal_gc;

  /* If the display is already accurate, do nothing.  */
  if (! rebuild
      && start == XINT (bar->start)
      && end == XINT (bar->end))

    end += VERTICAL_SCROLL_BAR_MIN_HANDLE;

    /* Draw the empty space above the handle.  Note that we can't clear
       zero-height areas; that means "clear to end of window."  */
    if (0 < start)
      XClearArea (x_current_display, w,

		  /* x, y, width, height, and exposures.  */
		  VERTICAL_SCROLL_BAR_LEFT_BORDER,
		  VERTICAL_SCROLL_BAR_TOP_BORDER,
		  inside_width, start,
		  False);

    /* Draw the handle itself.  */
    XFillRectangle (x_current_display, w, gc,

		    /* x, y, width, height */
		    VERTICAL_SCROLL_BAR_LEFT_BORDER,
		    VERTICAL_SCROLL_BAR_TOP_BORDER + start,
		    inside_width, end - start);


    /* Draw the empty space below the handle.  Note that we can't
       clear zero-height areas; that means "clear to end of window." */
    if (end < inside_height)
      XClearArea (x_current_display, w,

		  /* x, y, width, height, and exposures.  */
		  VERTICAL_SCROLL_BAR_LEFT_BORDER,
		  VERTICAL_SCROLL_BAR_TOP_BORDER + end,
		  inside_width, inside_height - end,

static void
x_scroll_bar_move (bar, top, left, width, height)
     struct scroll_bar *bar;
     int top, left, width, height;
{
  BLOCK_INPUT;

  {
    XWindowChanges wc;
    unsigned int mask = 0;

    if (top != XINT (bar->top))		mask |= CWY;
    if (width != XINT (bar->width))	mask |= CWWidth;
    if (height != XINT (bar->height))	mask |= CWHeight;

    if (mask)
      XConfigureWindow (x_current_display, SCROLL_BAR_X_WINDOW (bar),
			mask, &wc);
  }

  XSETINT (bar->left, left);
  XSETINT (bar->top, top);

  FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));

  BLOCK_INPUT;

  /* Destroy the window.  */
  XDestroyWindow (x_current_display, SCROLL_BAR_X_WINDOW (bar));

  /* Disassociate this scroll bar from its window.  */
  XWINDOW (bar->window)->vertical_scroll_bar = Qnil;

  UNBLOCK_INPUT;

x_scroll_bar_expose (bar, event)
     struct scroll_bar *bar;
     XEvent *event;
{
  Window w = SCROLL_BAR_X_WINDOW (bar);
  GC gc = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))->display.x->normal_gc;

  BLOCK_INPUT;

  x_scroll_bar_set_handle (bar, XINT (bar->start), XINT (bar->end), 1);

  /* Draw a one-pixel border just inside the edges of the scroll bar. */
  XDrawRectangle (x_current_display, w, gc,

		  /* x, y, width, height */
		  0, 0, XINT (bar->width) - 1, XINT (bar->height) - 1);

  UNBLOCK_INPUT;

    abort ();

  emacs_event->kind = scroll_bar_click;
  emacs_event->code = event->xbutton.button - Button1;
  emacs_event->modifiers =
    (x_x_to_emacs_modifiers (event->xbutton.state)
     | (event->type == ButtonRelease
	? up_modifier
	: down_modifier));
  emacs_event->frame_or_window = bar->window;
  emacs_event->timestamp = event->xbutton.time;

}

/* Return information to the user about the current position of the mouse
   on the scroll bar.  */
static void
x_scroll_bar_report_motion (f, bar_window, part, x, y, time)
     FRAME_PTR *f;
     Lisp_Object *bar_window;
     enum scroll_bar_part *part;
     Lisp_Object *x, *y;
     unsigned long *time;
{
  struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
  int win_x, win_y;
  Window dummy_window;
  int dummy_coord;
  unsigned int dummy_mask;

  BLOCK_INPUT;

  /* Get the mouse's position relative to the scroll bar window, and
     report that.  */
  if (! XQueryPointer (x_current_display,
		       SCROLL_BAR_X_WINDOW (bar),

		       /* Root, child, root x and root y.  */
		       &dummy_window, &dummy_window,
		       &dummy_coord, &dummy_coord,

		       /* Position relative to scroll bar.  */
		       &win_x, &win_y,

		       /* Mouse buttons and modifier keys.  */
		       &dummy_mask))
    *f = 0;
  else
    {
      int inside_height
	= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar->height));
      int top_range

      if (win_y < 0)
	win_y = 0;
      if (win_y > top_range)
	win_y = top_range;

      *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
      *bar_window = bar->window;

      if (! NILP (bar->dragging))
	*part = scroll_bar_handle;
      else if (win_y < XINT (bar->start))
	*part = scroll_bar_above_handle;

{
  Lisp_Object bar;

  for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
       bar = XSCROLL_BAR (bar)->next)
    XClearArea (x_current_display, SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)),
		0, 0, 0, 0, True);
}

/* This processes Expose events from the menubar specific X event
   loop in menubar.c.  This allows to redisplay the frame if necessary

static int x_queue_selection_requests;

/* Queue up an X event *EVENT, to be processed later.  */

static void
x_queue_event (event)
     XEvent *event;
{
  struct selection_event_queue *queue_tmp
    = (struct selection_event_queue *) malloc (sizeof (struct selection_event_queue));

/* Take all the queued events and put them back
   so that they get processed afresh.  */

static void
x_unqueue_events ()
{
  while (queue != NULL)
    {
      struct selection_event_queue *queue_tmp = queue;
      XPutBackEvent (XDISPLAY &queue_tmp->event);
      queue = queue_tmp->next;
      free ((char *)queue_tmp);
    }
}

/* Start queuing SelectionRequest events.  */

void
x_start_queuing_selection_requests ()
{
  x_queue_selection_requests++;
}

/* Stop queuing SelectionRequest events.  */

void
x_stop_queuing_selection_requests ()
{
  x_queue_selection_requests--;
  x_unqueue_events ();
}

/* The main X event-reading loop - XTread_socket.  */

/* Timestamp of enter window event.  This is only used by XTread_socket,

   me that letting the compiler initialize it to zeros will work okay.

   This must be defined outside of XTread_socket, for the same reasons
   given for enter_timestamp, above.  */
static XComposeStatus compose_status;

/* Communication with window managers. */
Atom Xatom_wm_protocols;

/* Kinds of protocol things we may receive. */
Atom Xatom_wm_take_focus;
Atom Xatom_wm_save_yourself;
Atom Xatom_wm_delete_window;

/* Other WM communication */
Atom Xatom_wm_configure_denied;	  /* When our config request is denied */
Atom Xatom_wm_window_moved;	  /* When the WM moves us. */

/* Window manager communication.  */
Atom Xatom_wm_change_state;

/* EditRes protocol */
Atom Xatom_editres_name;

/* Record the last 100 characters stored
   to help debug the loss-of-chars-during-GC problem.  */
int temp_index;
short temp_buffer[100];

  XEvent event;
  struct frame *f;
  int event_found = 0;
  int prefix;
  Lisp_Object part;

  if (interrupt_input_blocked)
    {
      interrupt_input_pending = 1;
      return -1;
    }

  interrupt_input_pending = 0;
  BLOCK_INPUT;

  /* So people can tell when we have read the available input.  */
  input_signal_count++;

  if (numchars <= 0)

#ifdef FIOSNBIO
  /* If available, Xlib uses FIOSNBIO to make the socket
     non-blocking, and then looks for EWOULDBLOCK.  If O_NDELAY is set,
     FIOSNBIO is ignored, and instead of signalling EWOULDBLOCK,
     a read returns 0, which Xlib interprets as equivalent to EPIPE. */
  fcntl (fileno (stdin), F_SETFL, 0);
#endif /* ! defined (FIOSNBIO) */

#ifndef SIGIO
#ifndef HAVE_SELECT
  if (! (fcntl (fileno (stdin), F_GETFL, 0) & O_NDELAY))
    {
      extern int read_alarm_should_throw;
      read_alarm_should_throw = 1;
      XPeekEvent (XDISPLAY &event);
      read_alarm_should_throw = 0;
    }
#endif /* HAVE_SELECT */
#endif /* SIGIO */

  while (XStuffPending () != 0)
    {
      XNextEvent (XDISPLAY &event);
      event_found = 1;

      switch (event.type)
	{
	case ClientMessage:
	  {
	    if (event.xclient.message_type == Xatom_wm_protocols
		&& event.xclient.format == 32)
	      {
		if (event.xclient.data.l[0] == Xatom_wm_take_focus)
		  {
		    f = x_window_to_frame (event.xclient.window);
		    /* Since we set WM_TAKE_FOCUS, we must call
		       XSetInputFocus explicitly.  But not if f is null,
		       since that might be an event for a deleted frame.  */

				      event.xclient.window,
				      RevertToPointerRoot,
				      event.xclient.data.l[1]);
		    /* Not certain about handling scroll bars here */
		  }
		else if (event.xclient.data.l[0] == Xatom_wm_save_yourself)
		  {
		    /* Save state modify the WM_COMMAND property to
		       something which can reinstate us. This notifies
		       the session manager, who's looking for such a
		       PropertyNotify.  Can restart processing when
		       a keyboard or mouse event arrives. */
		    if (numchars > 0)
		      {
			/* This is just so we only give real data once
			   for a single Emacs process.  */
			if (x_top_window_to_frame (event.xclient.window)
			    == selected_frame)
			  XSetCommand (x_current_display,
				       event.xclient.window,
				       initial_argv, initial_argc);
			else
			  XSetCommand (x_current_display,
				       event.xclient.window,
				       0, 0);
		      }
		  }
		else if (event.xclient.data.l[0] == Xatom_wm_delete_window)
		  {
		    struct frame *f = x_any_window_to_frame (event.xclient.window);

		    if (f)
		      {

			count += 1;
			numchars -= 1;
		      }
		  }
	      }
	    else if (event.xclient.message_type == Xatom_wm_configure_denied)
	      {
	      }
	    else if (event.xclient.message_type == Xatom_wm_window_moved)
	      {
		int new_x, new_y;
		struct frame *f = x_window_to_frame (event.xclient.window);

		new_x = event.xclient.data.s[0];

		    f->display.x->left_pos = new_x;
		    f->display.x->top_pos = new_y;
		  }
	      }
#if defined (USE_X_TOOLKIT) && defined (HAVE_X11R5)
	    else if (event.xclient.message_type == Xatom_editres_name)
	      {
		struct frame *f = x_any_window_to_frame (event.xclient.window);
		_XEditResCheckMessages (f->display.x->widget, NULL, &event, NULL);
	      }
#endif /* USE_X_TOOLKIT and HAVE_X11R5 */

#ifdef USE_X_TOOLKIT
	  if (!x_window_to_frame (event.xselectionrequest.owner))
	    goto OTHER;
#endif /* USE_X_TOOLKIT */
	  if (x_queue_selection_requests)
	    x_queue_event (&event);
	  else
	    {
	      XSelectionRequestEvent *eventp = (XSelectionRequestEvent *) &event;

	      if (numchars == 0)

		 80 fixed a bug whereby meta chars made his Emacs hang.  */
	      unsigned char copy_buffer[81];
	      int modifiers;

	      event.xkey.state
		|= x_emacs_to_x_modifiers (extra_keyboard_modifiers);
	      modifiers = event.xkey.state;

	      /* This will have to go some day...  */

	      /* make_lispy_event turns chars into control chars.

			temp_index = 0;
		      temp_buffer[temp_index++] = keysym;
		      bufp->kind = non_ascii_keystroke;
		      bufp->code = keysym;
		      XSETFRAME (bufp->frame_or_window, f);
		      bufp->modifiers = x_x_to_emacs_modifiers (modifiers);
		      bufp->timestamp = event.xkey.time;
		      bufp++;
		      count++;
		      numchars--;
		    }

			    temp_index = 0;
			  temp_buffer[temp_index++] = copy_buffer[i];
			  bufp->kind = ascii_keystroke;
			  bufp->code = copy_buffer[i];
			  XSETFRAME (bufp->frame_or_window, f);
			  bufp->modifiers = x_x_to_emacs_modifiers (modifiers);
			  bufp->timestamp = event.xkey.time;
			  bufp++;
			}

		      count += nbytes;

#endif /* USE_X_TOOLKIT */
	  break;

	case MotionNotify:
	  {
	    if (x_mouse_grabbed && last_mouse_frame
		&& FRAME_LIVE_P (last_mouse_frame))
	      f = last_mouse_frame;
	    else
	      f = x_window_to_frame (event.xmotion.window);
	    if (f)

              /* Find the position of the outside upper-left corner of
                 the window, in the root coordinate system.  Don't
                 refer to the parent window here; we may be processing
                 this event after the window manager has changed our
                 parent, but before we have reached the ReparentNotify.  */
              XTranslateCoordinates (x_current_display,

                                     /* From-window, to-window.  */
                                     XtWindow (f->display.x->widget),
                                     ROOT_WINDOW,

                                     /* From-position, to-position.  */
                                     -event.xconfigure.border_width,
                                     -event.xconfigure.border_width,
                                     &win_x, &win_y,

		  /* Find the position of the outside upper-left corner of
		     the window, in the root coordinate system.  Don't
		     refer to the parent window here; we may be processing
		     this event after the window manager has changed our
		     parent, but before we have reached the ReparentNotify.  */
		  XTranslateCoordinates (x_current_display,

					 /* From-window, to-window.  */
					 f->display.x->window_desc,
					 ROOT_WINDOW,

					 /* From-position, to-position.  */
					 -event.xconfigure.border_width,
					 -event.xconfigure.border_width,
					 &win_x, &win_y,

#endif /* USE_X_TOOLKIT */
	      }

	    if (event.type == ButtonPress)
	      {
		x_mouse_grabbed |= (1 << event.xbutton.button);
		Vmouse_depressed = Qt;
		last_mouse_frame = f;
	      }
	    else
	      {
		x_mouse_grabbed &= ~(1 << event.xbutton.button);
		if (!x_mouse_grabbed)
		  Vmouse_depressed = Qnil;
	      }

	    if (numchars >= 1 && emacs_event.kind != no_event)
	      {
		bcopy (&emacs_event, bufp, sizeof (struct input_event));

	  /* Someone has changed the keyboard mapping - update the
	     local cache.  */
	  switch (event.xmapping.request)
	    {
	    case MappingModifier:
	      x_find_modifier_meanings ();
	      /* This is meant to fall through.  */
	    case MappingKeyboard:
	      XRefreshKeyboardMapping (&event.xmapping);
	    }
#ifdef USE_X_TOOLKIT

	 B. Bretthauer, 1994 */
      x_noop_count++;
      if (x_noop_count >= 100)
	{
	  x_noop_count=0;
	  XNoOp (x_current_display);
	}
    }

#if 0 /* This fails for serial-line connections to the X server,
	 because the characters arrive one by one, and a partial

  if (expected && ! event_found)
    {
      /* AOJ 880406: if select returns true but XPending doesn't, it means that
	 there is an EOF condition; in other words, that X has died.
	 Act as if there had been a hangup. */
      int fd = ConnectionNumber (x_current_display);
      SELECT_TYPE mask, junk1, junk2;
      EMACS_TIME timeout;

      FD_ZERO (&mask);
      FD_SET (fd, &mask);
      EMACS_SET_SECS_USECS (timeout, 0, 0);
      FD_ZERO (&junk1);
      FD_ZERO (&junk2);
      if (0 != select (fd + 1, &mask, &junk1, &junk2, &timeout)
	  && !XStuffPending ())
	kill (getpid (), SIGHUP);
    }
#endif /* HAVE_SELECT */
#endif /* 0 */

  int left = CHAR_TO_PIXEL_COL (f, curs_x);
  int top  = CHAR_TO_PIXEL_ROW (f, curs_y);
  int width = FONT_WIDTH (f->display.x->font);
  int height = f->display.x->line_height;

  XDrawRectangle (x_current_display, FRAME_X_WINDOW (f),
		  f->display.x->cursor_gc,
		  left, top, width - 1, height - 1);
}

/* Clear the cursor of frame F to background color,

      f->phys_cursor_glyph
	= ((current_glyphs->enable[curs_y]
	    && curs_x < current_glyphs->used[curs_y])
	   ? current_glyphs->glyphs[curs_y][curs_x]
	   : SPACEGLYPH);
      XFillRectangle (x_current_display, FRAME_X_WINDOW (f),
		      f->display.x->cursor_gc,
		      CHAR_TO_PIXEL_COL (f, curs_x),
		      CHAR_TO_PIXEL_ROW (f, curs_y),
		      1, f->display.x->line_height);

      f->display.x->current_cursor = bar_cursor;
    }

  if (updating_frame != f)
    XFlushQueue ();
}


/* Turn the displayed cursor of frame F on or off according to ON.
   If ON is nonzero, where to put the cursor is specified

	mouse_face_here = 1;

      /* If the font is not as tall as a whole line,
	 we must explicitly clear the line's whole height.  */
      if (FONT_HEIGHT (f->display.x->font) != f->display.x->line_height)
	XClearArea (x_current_display, FRAME_X_WINDOW (f),
		    CHAR_TO_PIXEL_COL (f, f->phys_cursor_x),
		    CHAR_TO_PIXEL_ROW (f, f->phys_cursor_y),
		    FONT_WIDTH (f->display.x->font),
		    f->display.x->line_height, False);
      /* Erase the cursor by redrawing the character underneath it.  */

      f->phys_cursor_x = curs_x;
      f->phys_cursor_y = curs_y;
    }

  if (updating_frame != f)
    XFlushQueue ();
}

x_display_cursor (f, on)
     struct frame *f;
     int on;

  if (STRINGP (file))
    bitmap_id = x_create_bitmap_from_file (f, file);
  else
    {
      /* Create the GNU bitmap if necessary.  */
      if (!icon_bitmap)
	icon_bitmap = x_create_bitmap_from_data (f, gnu_bits,
						 gnu_width, gnu_height);

      /* The first time we create the GNU bitmap,
	 this increments the refcount one extra time.
	 As a result, the GNU bitmap is never freed.
	 That way, we don't have to worry about allocating it again.  */
      x_reference_bitmap (f, icon_bitmap);

      bitmap_id = icon_bitmap;
    }

  x_wm_set_icon_pixmap (f, bitmap_id);
  f->display.x->icon_bitmap = bitmap_id;

  else
    if (! f->display.x->icon_label)
      f->display.x->icon_label = " *emacs* ";

#if 0
  XSetIconName (x_current_display, FRAME_X_WINDOW (f),
		(char *) f->display.x->icon_label);
#endif

  if (f->display.x->icon_bitmap > 0)
    x_destroy_bitmap (f, f->display.x->icon_bitmap);

  XGetErrorText (display, error->error_code,
		 x_caught_error_message, X_CAUGHT_ERROR_MESSAGE_SIZE);
}


/* Begin trapping X errors.

   After calling this function, X protocol errors no longer cause
   Emacs to exit; instead, they are recorded in x_cfc_error_message.

   Calling x_check_errors signals an Emacs error if an X error has

   Calling x_uncatch_errors resumes the normal error handling.  */

void x_catch_errors (), x_check_errors (), x_uncatch_errors ();

void
x_catch_errors ()
{
  /* Make sure any errors from previous requests have been dealt with.  */
  XSync (x_current_display, False);

  /* Set up the error buffer.  */
  x_caught_error_message
    = (char*) xmalloc (X_CAUGHT_ERROR_MESSAGE_SIZE);
  x_caught_error_message[0] = '\0';

  /* Install our little error handler.  */
  XHandleError (x_error_catcher);
}

/* If any X protocol errors have arrived since the last call to
   x_catch_errors or x_check_errors, signal an Emacs error using
   sprintf (a buffer, FORMAT, the x error message text) as the text.  */

void
x_check_errors (format)
     char *format;
{
  /* Make sure to catch any errors incurred so far.  */
  XSync (x_current_display, False);

  if (x_caught_error_message[0])
    {
      char buf[X_CAUGHT_ERROR_MESSAGE_SIZE + 56];

      sprintf (buf, format, x_caught_error_message);
      x_uncatch_errors ();
      error (buf);
    }
}

/* Nonzero if we had any X protocol errors since we did x_catch_errors.  */

int
x_had_errors_p ()
{
  /* Make sure to catch any errors incurred so far.  */
  XSync (x_current_display, False);

  return x_caught_error_message[0] != 0;
}

/* Stop catching X protocol errors and let them make Emacs die.  */

void
x_uncatch_errors ()
{
  xfree (x_caught_error_message);
  x_caught_error_message = 0;
  XHandleError (x_error_quitter);
}

#if 0
static unsigned int x_wire_count;
x_trace_wire ()

  char **font_names;

  /* Get a list of all the fonts that match this name.  Once we
     have a list of matching fonts, we compare them against the fonts
     we already have by comparing font ids.  */
  font_names = (char **) XListFonts (x_current_display, fontname,
				     1024, &n_matching_fonts);
  /* Apparently it doesn't set n_matching_fonts to zero when it can't
     find any matches; font_names == 0 is the only clue.  */
  if (! font_names)
    n_matching_fonts = 0;

      /* See comment above.  */
      if (n_matching_fonts != 0)
	fontname = font_names[i];

      font = (XFontStruct *) XLoadQueryFont (x_current_display, fontname);
      if (! font)
	{
	  /* Free the information from XListFonts.  */
	  if (n_matching_fonts)
	    XFreeFontNames (font_names);

      /* Try to get the full name of FONT.  Put it in full_name.  */
      full_name = 0;
      for (i = 0; i < font->n_properties; i++)
	{
	  char *atom
	    = XGetAtomName (x_current_display, font->properties[i].name);
	  if (!strcmp (atom, "FONT"))
	    {
	      char *name = XGetAtomName (x_current_display,
					 (Atom) (font->properties[i].card32));
	      char *p = name;
	      int dashes = 0;

	      /* Count the number of dashes in the "full name".

    f->scroll_bar_cols = 2;

  /* Now make the frame display the given font.  */
  if (FRAME_X_WINDOW (f) != 0)
    {
      XSetFont (x_current_display, f->display.x->normal_gc,
		f->display.x->font->fid);
      XSetFont (x_current_display, f->display.x->reverse_gc,
		f->display.x->font->fid);
      XSetFont (x_current_display, f->display.x->cursor_gc,
		f->display.x->font->fid);

      frame_update_line_height (f);
      x_set_window_size (f, 0, f->width, f->height);
    }

  int win_x = 0, win_y = 0;
  int flags = f->display.x->size_hint_flags;

  /* Find the position of the outside upper-left corner of
     the inner window, with respect to the outer window.  */
  if (f->display.x->parent_desc != ROOT_WINDOW)
    {
      BLOCK_INPUT;
      XTranslateCoordinates (x_current_display,

			     /* From-window, to-window.  */
			     f->display.x->window_desc,
			     f->display.x->parent_desc,

    }

  /* Treat negative positions as relative to the leftmost bottommost
     position that fits on the screen.  */
  if (flags & XNegative)
    f->display.x->left_pos = (x_screen_width
			      - 2 * f->display.x->border_width - win_x
			      - PIXEL_WIDTH (f)
			      + f->display.x->left_pos);

  if (flags & YNegative)
    f->display.x->top_pos = (x_screen_height
			     - 2 * f->display.x->border_width - win_y
			     - PIXEL_HEIGHT (f)
			     + f->display.x->top_pos);
  /* The left_pos and top_pos
     are now relative to the top and left screen edges,

  BLOCK_INPUT;
  x_wm_set_size_hint (f, 0, 0);

#ifdef USE_X_TOOLKIT
  XMoveWindow (XDISPLAY XtWindow (f->display.x->widget),
	       f->display.x->left_pos, f->display.x->top_pos);
#else /* not USE_X_TOOLKIT */
  XMoveWindow (XDISPLAY FRAME_X_WINDOW (f),
	       f->display.x->left_pos, f->display.x->top_pos);
#endif /* not USE_X_TOOLKIT */
  UNBLOCK_INPUT;
}

  pixelheight = CHAR_TO_PIXEL_HEIGHT (f, rows);

  f->display.x->win_gravity = NorthWestGravity;
  x_wm_set_size_hint (f, 0, 0);

  XSync (x_current_display, False);
  XChangeWindowSize (FRAME_X_WINDOW (f), pixelwidth, pixelheight);

  /* Now, strictly speaking, we can't be sure that this is accurate,
     but the window manager will get around to dealing with the size
     change request eventually, and we'll hear how it went when the
     ConfigureNotify event gets here.

     receive in the ConfigureNotify event; if we get what we asked
     for, then the event won't cause the screen to become garbaged, so
     we have to make sure to do it here.  */
  SET_FRAME_GARBAGED (f);

  XFlushQueue ();
  UNBLOCK_INPUT;
#endif /* not USE_X_TOOLKIT */
}

/* Mouse warping, focus shifting, raising and lowering.  */

  if (pix_y < 0) pix_y = 0;
  if (pix_y > PIXEL_HEIGHT (f)) pix_y = PIXEL_HEIGHT (f);

  BLOCK_INPUT;

  XWarpMousePointer (FRAME_X_WINDOW (f), pix_x, pix_y);
  UNBLOCK_INPUT;
}

/* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F.  */

     struct frame *f;
     int pix_x, pix_y;
{
  BLOCK_INPUT;

  XWarpMousePointer (FRAME_X_WINDOW (f), pix_x, pix_y);
  UNBLOCK_INPUT;
}

x_focus_on_frame (f)
     struct frame *f;

#endif
#if 0
  /* I don't think that the ICCCM allows programs to do things like this
     without the interaction of the window manager.  Whatever you end up
     doing with this code, do it to x_unfocus_frame too.  */
  XSetInputFocus (x_current_display, FRAME_X_WINDOW (f),
		  RevertToPointerRoot, CurrentTime);
#endif /* ! 0 */
}

x_unfocus_frame (f)
     struct frame *f;
{
#if 0
  /* Look at the remarks in x_focus_on_frame.  */
  if (x_focus_frame == f)
    XSetInputFocus (x_current_display, PointerRoot,
		    RevertToPointerRoot, CurrentTime);
#endif /* ! 0 */
}

/* Raise frame F.  */

{
  if (f->async_visible)
    {
      BLOCK_INPUT;
#ifdef USE_X_TOOLKIT
      XRaiseWindow (XDISPLAY XtWindow (f->display.x->widget));
#else /* not USE_X_TOOLKIT */
      XRaiseWindow (XDISPLAY FRAME_X_WINDOW (f));
#endif /* not USE_X_TOOLKIT */
      XFlushQueue ();
      UNBLOCK_INPUT;
    }
}

/* Lower frame F.  */

{
  if (f->async_visible)
    {
      BLOCK_INPUT;
#ifdef USE_X_TOOLKIT
      XLowerWindow (XDISPLAY XtWindow (f->display.x->widget));
#else /* not USE_X_TOOLKIT */
      XLowerWindow (XDISPLAY FRAME_X_WINDOW (f));
#endif /* not USE_X_TOOLKIT */
      XFlushQueue ();
      UNBLOCK_INPUT;
    }
}

static void

	x_wm_set_window_state (f, NormalState);
#ifdef USE_X_TOOLKIT
      /* This was XtPopup, but that did nothing for an iconified frame.  */
      XtMapWidget (f->display.x->widget);
#else /* not USE_X_TOOLKIT */
      XMapWindow (XDISPLAY FRAME_X_WINDOW (f));
#endif /* not USE_X_TOOLKIT */
#if 0 /* This seems to bring back scroll bars in the wrong places
	 if the window configuration has changed.  They seem
	 to come back ok without this.  */
      if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
	XMapSubwindows (x_current_display, FRAME_X_WINDOW (f));
#endif
    }

  XFlushQueue ();

  /* Synchronize to ensure Emacs knows the frame is visible
     before we do anything else.  We do this loop with input not blocked
     so that incoming events are handled.  */
  {

    XSETFRAME (frame, f);

    while (1)
      {
	x_sync (frame);
	/* Once we have handled input events,
	   we should have received the MapNotify if one is coming.
	   So if we have not got it yet, stop looping.
	   Some window managers make their own decisions
	   about visibility.  */

     by hand again (they have already done that once for this window.)  */
  x_wm_set_size_hint (f, 0, 1);

#ifdef HAVE_X11R4

  if (! XWithdrawWindow (x_current_display, window,
			 DefaultScreen (x_current_display)))
    {
      UNBLOCK_INPUT_RESIGNAL;
      error ("Can't notify window manager of window withdrawal");
    }
#else /* ! defined (HAVE_X11R4) */

    {
      XEvent unmap;

      unmap.xunmap.type = UnmapNotify;
      unmap.xunmap.window = window;
      unmap.xunmap.event = DefaultRootWindow (x_current_display);
      unmap.xunmap.from_configure = False;
      if (! XSendEvent (x_current_display,
			DefaultRootWindow (x_current_display),
			False,
			SubstructureRedirectMask|SubstructureNotifyMask,
			&unmap))
	{
	  UNBLOCK_INPUT_RESIGNAL;
	  error ("Can't notify window manager of withdrawal");
	}
    }

  /* Unmap the window ourselves.  Cheeky!  */
  XUnmapWindow (x_current_display, window);
#endif /* ! defined (HAVE_X11R4) */

  /* We can't distinguish this from iconification
     just by the event that we get from the server.
     So we can't win using the usual strategy of letting

  f->visible = 0;
  FRAME_ICONIFIED_P (f) = 0;
  f->async_visible = 0;
  f->async_iconified = 0;

  x_sync ();

  UNBLOCK_INPUT;
}

/* Change window state from mapped to iconified. */

      XtMapWidget (f->display.x->widget);
      UNBLOCK_INPUT;
      return;
    }

  result = XIconifyWindow (x_current_display,
			   XtWindow (f->display.x->widget),
			   DefaultScreen (x_current_display));
  UNBLOCK_INPUT;

  if (!result)
    error ("Can't notify window manager of iconification");

  f->async_iconified = 1;

  BLOCK_INPUT;
  XFlushQueue ();
  UNBLOCK_INPUT;
#else /* not USE_X_TOOLKIT */

  /* Make sure the X server knows where the window should be positioned,
     in case the user deiconifies with the window manager.  */

  {
    XEvent message;

    message.xclient.window = FRAME_X_WINDOW (f);
    message.xclient.type = ClientMessage;
    message.xclient.message_type = Xatom_wm_change_state;
    message.xclient.format = 32;
    message.xclient.data.l[0] = IconicState;

    if (! XSendEvent (x_current_display,
		      DefaultRootWindow (x_current_display),
		      False,
		      SubstructureRedirectMask | SubstructureNotifyMask,
		      &message))
      {
	UNBLOCK_INPUT_RESIGNAL;

  x_wm_set_window_state (f, IconicState);

  if (!FRAME_VISIBLE_P (f))
    {
      /* If the frame was withdrawn, before, we must map it.  */
      XMapWindow (XDISPLAY FRAME_X_WINDOW (f));
#if 0 /* We don't have subwindows in the icon.  */
      if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
	XMapSubwindows (x_current_display, FRAME_X_WINDOW (f));
#endif
    }

  f->async_iconified = 1;

  XFlushQueue ();
  UNBLOCK_INPUT;
#endif /* not USE_X_TOOLKIT */
}

/* Destroy the X window of frame F.  */

     struct frame *f;
{
  BLOCK_INPUT;

  if (f->display.x->icon_desc != 0)
    XDestroyWindow (XDISPLAY f->display.x->icon_desc);
  XDestroyWindow (XDISPLAY f->display.x->window_desc);
#ifdef USE_X_TOOLKIT
  XtDestroyWidget (f->display.x->widget);
  free_frame_menubar (f);
#endif /* USE_X_TOOLKIT */

  free_frame_faces (f);
  XFlushQueue ();

  FRAME_X_SCREEN (f)->reference_count--;
#if 0
  if (FRAME_X_SCREEN (f)->reference_count == 0)
    free (FRAME_X_SCREEN (f));
#endif

  xfree (f->display.x);
  f->display.x = 0;
  if (f == x_focus_frame)

  size_hints.width = PIXEL_WIDTH (f);
#endif /* not USE_X_TOOLKIT */

  size_hints.width_inc = FONT_WIDTH (f->display.x->font);
  size_hints.height_inc = f->display.x->line_height;
  size_hints.max_width = x_screen_width - CHAR_TO_PIXEL_WIDTH (f, 0);
  size_hints.max_height = x_screen_height - CHAR_TO_PIXEL_HEIGHT (f, 0);

  {
    int base_width, base_height;
    int min_rows = 0, min_cols = 0;

      XSizeHints hints;		/* Sometimes I hate X Windows... */
      long supplied_return;
      int value;

#ifdef HAVE_X11R4
      value = XGetWMNormalHints (x_current_display, window, &hints,
				 &supplied_return);
#else
      value = XGetNormalHints (x_current_display, window, &hints);
#endif

      if (value == 0)
	hints.flags = 0;
      if (hints.flags & PSize)

      size_hints.flags |= USPosition;
    }
#endif /* PWinGravity */

#ifdef HAVE_X11R4
  XSetWMNormalHints (x_current_display, window, &size_hints);
#else
  XSetNormalHints (x_current_display, window, &size_hints);
#endif
}

/* Used for IconicState or NormalState */
x_wm_set_window_state (f, state)

  Window window = FRAME_X_WINDOW (f);

  f->display.x->wm_hints.flags |= StateHint;
  f->display.x->wm_hints.initial_state = state;

  XSetWMHints (x_current_display, window, &f->display.x->wm_hints);
#endif /* not USE_X_TOOLKIT */
}

x_wm_set_icon_pixmap (f, pixmap_id)
     struct frame *f;

    {
      f->display.x->wm_hints.icon_pixmap = None;
      f->display.x->wm_hints.flags &= ~IconPixmapHint;
    }

  XSetWMHints (x_current_display, window, &f->display.x->wm_hints);
}

x_wm_set_icon_position (f, icon_x, icon_y)
     struct frame *f;
     int icon_x, icon_y;

  f->display.x->wm_hints.flags |= IconPositionHint;
  f->display.x->wm_hints.icon_x = icon_x;
  f->display.x->wm_hints.icon_y = icon_y;

  XSetWMHints (x_current_display, window, &f->display.x->wm_hints);
}


/* Initialization.  */

  {"-mc",	"*pointerColor", XrmoptionSepArg, (XtPointer) NULL},
  {"-cr",	"*cursorColor", XrmoptionSepArg, (XtPointer) NULL}
};
#endif /* USE_X_TOOLKIT */

void
x_term_init (display_name, xrm_option, resource_name)
     char *display_name;
     char *xrm_option;
     char *resource_name;
{
  Lisp_Object frame;
  char *defaultvalue;
  int argc = 0;
  char** argv = 0;
#ifndef F_SETOWN_BUG
#ifdef F_SETOWN
  extern int old_fcntl_owner;
#endif /* ! defined (F_SETOWN) */
#endif /* F_SETOWN_BUG */

  x_noop_count = 0;

  x_focus_frame = x_highlight_frame = 0;

#ifdef USE_X_TOOLKIT

#endif

  argv = (char **) XtMalloc (7 * sizeof (char *));
  argv[0] = "";
  argv[1] = "-display";
  argv[2] = display_name;
  argv[3] = "-name";
  /* Usually `emacs', but not always.  */
  argv[4] = resource_name;
  argc = 5;
  if (xrm_option)

  Xt_app_shell = XtAppInitialize (&Xt_app_con, "Emacs",
				  emacs_options, XtNumber (emacs_options),
				  &argc, argv,
				  NULL, NULL, 0);
  XtFree ((char *)argv);
  x_current_display = XtDisplay (Xt_app_shell);

#else /* not USE_X_TOOLKIT */
#ifdef HAVE_X11R5
  XSetLocaleModifiers ("");
#endif
  x_current_display = XOpenDisplay (display_name);
#endif /* not USE_X_TOOLKIT */
  if (x_current_display == 0)
    fatal ("X server %s not responding.\n\
Check the DISPLAY environment variable or use \"-d\"\n",
	   display_name);

  {
#if 0
    XSetAfterFunction (x_current_display, x_trace_wire);
#endif /* ! 0 */

    sprintf (x_id_name, "%s@%s",
	     XSTRING (Vinvocation_name)->data, XSTRING (Vsystem_name)->data);
  }

  /* Figure out which modifier bits mean what.  */
  x_find_modifier_meanings ();

  /* Get the scroll bar cursor.  */
  x_vertical_scroll_bar_cursor
    = XCreateFontCursor (x_current_display, XC_sb_v_double_arrow);

#if 0
  /* Watch for PropertyNotify events on the root window; we use them
     to figure out when to invalidate our cache of the cut buffers.  */
  x_watch_cut_buffer_cache ();
#endif

#ifdef subprocesses
  /* This is only needed for distinguishing keyboard and process input.  */
  if (ConnectionNumber (x_current_display) != 0)
    change_keyboard_wait_descriptor (ConnectionNumber (x_current_display));
#endif
  change_input_fd (ConnectionNumber (x_current_display));

#ifndef F_SETOWN_BUG
#ifdef F_SETOWN
  old_fcntl_owner = fcntl (ConnectionNumber (x_current_display), F_GETOWN, 0);
#ifdef F_SETOWN_SOCK_NEG
  /* stdin is a socket here */
  fcntl (ConnectionNumber (x_current_display), F_SETOWN, -getpid ());
#else /* ! defined (F_SETOWN_SOCK_NEG) */
  fcntl (ConnectionNumber (x_current_display), F_SETOWN, getpid ());
#endif /* ! defined (F_SETOWN_SOCK_NEG) */
#endif /* ! defined (F_SETOWN) */
#endif /* F_SETOWN_BUG */

#ifdef SIGIO

  /* Try to use interrupt input; if we can't, then start polling.  */
  Fset_input_mode (Qt, Qnil, Qt, Qnil);

  /* Note that there is no real way portable across R3/R4 to get the
     original error handler.  */
  XHandleError (x_error_quitter);
  XHandleIOError (x_io_error_quitter);

  /* Disable Window Change signals;  they are handled by X events. */
#ifdef SIGWINCH
  signal (SIGWINCH, SIG_DFL);
#endif /* ! defined (SIGWINCH) */

}

void
syms_of_xterm ()
{
  staticpro (&last_mouse_scroll_bar);
  last_mouse_scroll_bar = Qnil;
  staticpro (&mouse_face_window);
  mouse_face_window = Qnil;
}

9654:41681efe1086

#if defined (SIGIO) && defined (FIONREAD)
int BLOCK_INPUT_mask;
#endif /* ! defined (SIGIO) && defined (FIONREAD) */

/* Stuff for dealing with the main icon title. */

extern Lisp_Object Vcommand_line_args, Vsystem_name;
char *x_id_name;

/* Initial values of argv and argc.  */
extern char **initial_argv;
extern int initial_argc;

/* For now, we have just one x_display structure since we only support
   one X display.  */
static struct x_display_info the_x_screen;

/* This is a chain of structures for all the X displays currently in use.  */
struct x_display_info *x_display_list;

/* The cursor to use for vertical scroll bars on x_current_display.  */
static Cursor x_vertical_scroll_bar_cursor;

/* Frame being updated by update_frame.  This is declared in term.c.

   If the last X motion event didn't occur in a scroll bar, we set this
   to Qnil, to tell XTmouse_position to return an ordinary motion event.  */
static Lisp_Object last_mouse_scroll_bar;

/* This is a hack.  We would really prefer that XTmouse_position would
   return the time associated with the position it returns, but there
   doesn't seem to be any way to wrest the timestamp from the server
   along with the position query.  So, we just keep track of the time
   of the last movement we received, and return that in hopes that

static int volatile input_signal_count;
#else
static int input_signal_count;
#endif

/* Tells if a window manager is present or not. */

extern Lisp_Object Vx_no_window_manager;

/* Timestamp that we requested selection data was made. */

extern Lisp_Object Qface, Qmouse_face;

static int x_noop_count;

extern int errno;

/* A mask of extra modifier bits to put into every keyboard char.  */
extern int extra_keyboard_modifiers;

extern Display *XOpenDisplay ();
extern Window XCreateWindow ();

extern Cursor XCreateCursor ();
extern XFontStruct *XOpenFont ();
extern XrmDatabase x_load_resources ();

static void flashback ();
static void redraw_previous_char ();
static void redraw_following_char ();
static unsigned int x_x_to_emacs_modifiers ();

static void do_line_dance ();

void dumpborder ();
static int XTcursor_to ();
static int XTclear_end_of_line ();

/* Return the struct x_display_info corresponding to DPY.  */

struct x_display_info *
x_display_info_for_display (dpy)
     Display *dpy;
{
  struct x_display_info *dpyinfo;

  for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
    if (dpyinfo->display == dpy)
      return dpyinfo;

  return 0;
}

/* Starting and ending updates.

   These hooks are called by update_frame at the beginning and end
   of a frame update.  We record in `updating_frame' the identity

     for that case.  window_end_valid isn't set up yet.  */
  if (f == mouse_face_mouse_frame)
    note_mouse_highlight (f, mouse_face_mouse_x, mouse_face_mouse_y);
#endif

  XFlush (FRAME_X_DISPLAY (f));
  UNBLOCK_INPUT;
}

/* This is called after a redisplay on frame F.  */

  if (updating_frame == 0)
    {
      BLOCK_INPUT;
      x_display_cursor (selected_frame, 1);
      XFlush (FRAME_X_DISPLAY (selected_frame));
      UNBLOCK_INPUT;
    }
}

/* Display a sequence of N glyphs found at GP.

      /* Now output this run of chars, with the font and pixel values
	 determined by the face code CF.  */
      {
	struct face *face = FRAME_DEFAULT_FACE (f);
	XFontStruct *font = FACE_FONT (face);
	GC gc = FACE_GC (face);
	int stippled = 0;

	/* HL = 3 means use a mouse face previously chosen.  */
	if (hl == 3)

		  }
		xgcv.font = face->font->fid;
		xgcv.graphics_exposures = 0;
		mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
		if (scratch_cursor_gc)
		  XChangeGC (FRAME_X_DISPLAY (f), scratch_cursor_gc, mask, &xgcv);
		else
		  scratch_cursor_gc
		    = XCreateGC (FRAME_X_DISPLAY (f), window, mask, &xgcv);
		gc = scratch_cursor_gc;
#if 0
/* If this code is restored, it must also reset to the default stipple
   if necessary. */
		if (face->stipple && face->stipple != FACE_DEFAULT)
		  XSetStipple (FRAME_X_DISPLAY (f), gc, face->stipple);
#endif
	      }
	  }

	if ((int) font == FACE_DEFAULT)
	  font = f->display.x->font;

	if (just_foreground)
	  XDrawString (FRAME_X_DISPLAY (f), window, gc,
		       left, top + FONT_BASE (font), buf, len);
	else
	  {
	    if (stippled)
	      {
		/* Turn stipple on.  */
		XSetFillStyle (FRAME_X_DISPLAY (f), gc, FillOpaqueStippled);

		/* Draw stipple on background.  */
		XFillRectangle (FRAME_X_DISPLAY (f), window, gc,
				left, top,
				FONT_WIDTH (font) * len,
				FONT_HEIGHT (font));

		/* Turn stipple off.  */
		XSetFillStyle (FRAME_X_DISPLAY (f), gc, FillSolid);

		/* Draw the text, solidly, onto the stipple pattern.  */
		XDrawString (FRAME_X_DISPLAY (f), window, gc,
			     left, top + FONT_BASE (font), buf, len);
	      }
	    else
	      XDrawImageString (FRAME_X_DISPLAY (f), window, gc,
				left, top + FONT_BASE (font), buf, len);

	    /* Clear the rest of the line's height.  */
	    if (f->display.x->line_height != FONT_HEIGHT (font))
	      XClearArea (FRAME_X_DISPLAY (f), window, left,
			  top + FONT_HEIGHT (font),
			  FONT_WIDTH (font) * len,
			  /* This is how many pixels of height
			     we have to clear.  */
			  f->display.x->line_height - FONT_HEIGHT (font),

	  if (font->descent <= underline_position)
	    underline_position = font->descent - 1;

	  if (face->underline)
	    XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
			    FACE_GC (face),
			    left, (top
				   + FONT_BASE (font)
				   + underline_position),
			    len * FONT_WIDTH (font), 1);

     struct frame *f;
     int left, top;
     register GLYPH *gp; /* Points to first GLYPH. */
     register int n;  /* Number of glyphs to display. */
     int hl;
     XFontStruct *font;
{
  register int len;
  Window window = FRAME_X_WINDOW (f);
  GC drawing_gc =   (hl == 2 ? f->display.x->cursor_gc
		             : (hl ? f->display.x->reverse_gc
				   : f->display.x->normal_gc));

  if (sizeof (GLYPH) == sizeof (XChar2b))
    XDrawImageString16 (FRAME_X_DISPLAY (f), window, drawing_gc,
			left, top + FONT_BASE (font), (XChar2b *) gp, n);
  else if (sizeof (GLYPH) == sizeof (unsigned char))
    XDrawImageString (FRAME_X_DISPLAY (f), window, drawing_gc,
		      left, top + FONT_BASE (font), (char *) gp, n);
  else
    /* What size of glyph ARE you using?  And does X have a function to
       draw them?  */
    abort ();

  if (curs_y == f->phys_cursor_y
      && curs_x <= f->phys_cursor_x
      && f->phys_cursor_x < first_unused)
    f->phys_cursor_x = -1;

  XClearArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
	      CHAR_TO_PIXEL_COL (f, curs_x),
	      CHAR_TO_PIXEL_ROW (f, curs_y),
	      FONT_WIDTH (f->display.x->font) * (first_unused - curs_x),
	      f->display.x->line_height, False);
#if 0

  curs_x = 0;			/* Nominal cursor position is top left.  */
  curs_y = 0;

  BLOCK_INPUT;

  XClearWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));

  /* We have to clear the scroll bars, too.  If we have changed
     colors or something like that, then they should be notified.  */
  x_scroll_bar_clear (f);

  XFlush (FRAME_X_DISPLAY (f));
  UNBLOCK_INPUT;
}

#if 0
/* This currently does not work because FRAME_CURRENT_GLYPHS doesn't

  if (x > 0)
    {
      int start_x = x - 2;
      if (start_x < 0)
	start_x = 0;
      XClearArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		  CHAR_TO_PIXEL_COL (f, x - 1),
		  CHAR_TO_PIXEL_ROW (f, y),
		  FONT_WIDTH (f->display.x->font),
		  f->display.x->line_height, False);

      && FRAME_CURRENT_GLYPHS (f)->glyphs[y][x] != SPACEGLYPH)
    {
      int end_x = x + 2;
      if (end_x > limit)
	end_x = limit;
      XClearArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		  CHAR_TO_PIXEL_COL (f, x),
		  CHAR_TO_PIXEL_ROW (f, y),
		  FONT_WIDTH (f->display.x->font),
		  f->display.x->line_height, False);

      values.function = GXxor;
      values.foreground = (f->display.x->foreground_pixel
			   ^ f->display.x->background_pixel);

      gc = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		      GCFunction | GCForeground, &values);
    }

    {
      int width  = PIXEL_WIDTH  (f);
      int height = PIXEL_HEIGHT (f);

      XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
		      width/4, height/4, width/2, height/2);
      XFlush (FRAME_X_DISPLAY (f));

      {
	struct timeval wakeup, now;

	EMACS_GET_TIME (wakeup);

	    /* Try to wait that long--but we might wake up sooner.  */
	    select (0, 0, 0, 0, &timeout);
	  }
      }

      XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
		      width/4, height/4, width/2, height/2);
      XFreeGC (FRAME_X_DISPLAY (f), gc);
      XFlush (FRAME_X_DISPLAY (f));
    }
  }

  UNBLOCK_INPUT;
}

#endif


/* Make audible bell.  */

#define XRINGBELL XBell (FRAME_X_DISPLAY (selected_frame), 0)

XTring_bell ()
{
  if (FRAME_X_DISPLAY (selected_frame) == 0)
    return;

#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
  if (visible_bell)
    XTflash (selected_frame);
  else
#endif
    {
      BLOCK_INPUT;
      XRINGBELL;
      XFlush (FRAME_X_DISPLAY (selected_frame));
      UNBLOCK_INPUT;
    }
}

/* Insert and delete character.

    if (line_dance[i] != -1 && (distance = line_dance[i]-i) > 0)
      {
	for (j = i; (j < ht && line_dance[j] != -1
		     && line_dance[j]-j == distance); ++j);
	/* Copy [i,j) upward from [i+distance,j+distance) */
	XCopyArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		   FRAME_X_WINDOW (f), f->display.x->normal_gc,
		   intborder, CHAR_TO_PIXEL_ROW (f, i+distance),
		   f->width * FONT_WIDTH (f->display.x->font),
		   (j-i) * f->display.x->line_height,
		   intborder, CHAR_TO_PIXEL_ROW (f, i));

    if (line_dance[i] != -1 && (distance = line_dance[i]-i) < 0)
      {
	for (j = i; (--j >= 0 && line_dance[j] != -1
		     && line_dance[j]-j == distance););
	/* Copy (j,i] downward from (j+distance, i+distance] */
	XCopyArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		   FRAME_X_WINDOW (f), f->display.x->normal_gc,
		   intborder, CHAR_TO_PIXEL_ROW (f, j+1+distance),
		   f->width * FONT_WIDTH (f->display.x->font),
		   (i-j) * f->display.x->line_height,
		   intborder, CHAR_TO_PIXEL_ROW (f, j+1));

  for (i = 0; i < ht; ++i)
    if (line_dance[i] == -1)
      {
	for (j = i; j < ht && line_dance[j] == -1; ++j);
	/* Clear [i,j) */
	XClearArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		    intborder, CHAR_TO_PIXEL_ROW (f, i),
		    f->width * FONT_WIDTH (f->display.x->font),
		    (j-i) * f->display.x->line_height, False);
	i = j-1;
      }

  if (cursor_cleared)
    x_display_cursor (f, 1);
}

static void
frame_highlight (f)
     struct frame *f;
{
  /* We used to only do this if Vx_no_window_manager was non-nil, but
     the ICCCM (section 4.1.6) says that the window's border pixmap
     and border pixel are window attributes which are "private to the
     client", so we can always change it to whatever we want.  */
  BLOCK_INPUT;
  XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		    f->display.x->border_pixel);
  UNBLOCK_INPUT;
  x_display_cursor (f, 1);
}

static void
frame_unhighlight (f)
     struct frame *f;
{
  /* We used to only do this if Vx_no_window_manager was non-nil, but
     the ICCCM (section 4.1.6) says that the window's border pixmap
     and border pixel are window attributes which are "private to the
     client", so we can always change it to whatever we want.  */
  BLOCK_INPUT;
  XSetWindowBorderPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
			  f->display.x->border_tile);
  UNBLOCK_INPUT;
  x_display_cursor (f, 1);
}

static void XTframe_rehighlight ();

/* The focus has changed.  Update the frames as necessary to reflect

    }
}

/* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */

/* Initialize mode_switch_bit and modifier_meaning.  */
static void
x_find_modifier_meanings (dpyinfo)
     struct x_display_info *dpyinfo;
{
  int min_code, max_code;
  KeySym *syms;
  int syms_per_code;
  XModifierKeymap *mods;

  dpyinfo->meta_mod_mask = 0;
  dpyinfo->shift_lock_mask = 0;
  dpyinfo->alt_mod_mask = 0;
  dpyinfo->super_mod_mask = 0;
  dpyinfo->hyper_mod_mask = 0;

#ifdef HAVE_X11R4
  XDisplayKeycodes (dpyinfo->display, &min_code, &max_code);
#else
  min_code = display->min_keycode;
  max_code = display->max_keycode;
#endif

  syms = XGetKeyboardMapping (dpyinfo->display,
			      min_code, max_code - min_code + 1,
			      &syms_per_code);
  mods = XGetModifierMapping (dpyinfo->display);

  /* Scan the modifier table to see which modifier bits the Meta and
     Alt keysyms are on.  */
  {
    int row, col;	/* The row and column in the modifier table. */

		switch (sym)
		  {
		  case XK_Meta_L:
		  case XK_Meta_R:
		    dpyinfo->meta_mod_mask |= (1 << row);
		    break;

		  case XK_Alt_L:
		  case XK_Alt_R:
		    dpyinfo->alt_mod_mask |= (1 << row);
		    break;

		  case XK_Hyper_L:
		  case XK_Hyper_R:
		    dpyinfo->hyper_mod_mask |= (1 << row);
		    break;

		  case XK_Super_L:
		  case XK_Super_R:
		    dpyinfo->super_mod_mask |= (1 << row);
		    break;

		  case XK_Shift_Lock:
		    /* Ignore this if it's not on the lock modifier.  */
		    if ((1 << row) == LockMask)
		      dpyinfo->shift_lock_mask = LockMask;
		    break;
		  }
	      }
	  }
	}
  }

  /* If we couldn't find any meta keys, accept any alt keys as meta keys.  */
  if (! dpyinfo->meta_mod_mask)
    {
      dpyinfo->meta_mod_mask = dpyinfo->alt_mod_mask;
      dpyinfo->alt_mod_mask = 0;
    }

  /* If some keys are both alt and meta,
     make them just meta, not alt.  */
  if (dpyinfo->alt_mod_mask & dpyinfo->meta_mod_mask)
    {
      dpyinfo->alt_mod_mask &= ~dpyinfo->meta_mod_mask;
    }

  XFree ((char *) syms);
  XFreeModifiermap (mods);
}

/* Convert between the modifier bits X uses and the modifier bits
   Emacs uses.  */
static unsigned int
x_x_to_emacs_modifiers (dpyinfo, state)
     struct x_display_info *dpyinfo;
     unsigned int state;
{
  return (  ((state & (ShiftMask | dpyinfo->shift_lock_mask)) ? shift_modifier : 0)
	  | ((state & ControlMask)	       ? ctrl_modifier  : 0)
	  | ((state & dpyinfo->meta_mod_mask)  ? meta_modifier  : 0)
	  | ((state & dpyinfo->alt_mod_mask)   ? alt_modifier  : 0)
	  | ((state & dpyinfo->super_mod_mask) ? super_modifier  : 0)
	  | ((state & dpyinfo->hyper_mod_mask) ? hyper_modifier  : 0));
}

static unsigned int
x_emacs_to_x_modifiers (dpyinfo, state)
     struct x_display_info *dpyinfo;
     unsigned int state;
{
  return (  ((state & alt_modifier)	? dpyinfo->alt_mod_mask   : 0)
	  | ((state & super_modifier)	? dpyinfo->super_mod_mask : 0)
	  | ((state & hyper_modifier)	? dpyinfo->hyper_mod_mask : 0)
	  | ((state & shift_modifier)	? ShiftMask        : 0)
	  | ((state & ctrl_modifier)	? ControlMask      : 0)
	  | ((state & meta_modifier)	? dpyinfo->meta_mod_mask  : 0));
}

/* Mouse clicks and mouse movement.  Rah.  */

/* Given a pixel position (PIX_X, PIX_Y) on the frame F, return

  /* Make the event type no_event; we'll change that when we decide
     otherwise.  */
  result->kind = mouse_click;
  result->code = event->button - Button1;
  result->timestamp = event->time;
  result->modifiers = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
					       event->state)
		       | (event->type == ButtonRelease
			  ? up_modifier
			  : down_modifier));

  {

  /* Make the event type no_event; we'll change that when we decide
     otherwise.  */
  result->kind = mouse_click;
  XSETINT (result->code, event->button - Button1);
  result->timestamp = event->time;
  result->modifiers = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
					       event->state)
		       | (event->type == ButtonRelease
			  ? up_modifier
			  : down_modifier));

  XSETINT (result->x, event->x);

      return;
    }

  /* Find out which glyph the mouse is on.  */
  pixel_to_glyph_coords (f, x, y, &column, &row,
			 &new_glyph, FRAME_X_DISPLAY_INFO (f)->grabbed);

  /* Which window is that in?  */
  window = window_from_coordinates (f, column, row, &portion);
  w = XWINDOW (window);

  curs_x = old_curs_x;
  curs_y = old_curs_y;

  /* Change the mouse cursor according to the value of HL.  */
  if (hl > 0)
    XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		   f->display.x->cross_cursor);
  else
    XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		   f->display.x->text_cursor);
}

/* Clear out the mouse-highlighted active region.
   Redraw it unhighlighted first.  */

   movement.  This also calls XQueryPointer, which will cause the
   server to give us another MotionNotify when the mouse moves
   again. */

static void
XTmouse_position (fp, bar_window, part, x, y, time)
     FRAME_PTR *fp;
     Lisp_Object *bar_window;
     enum scroll_bar_part *part;
     Lisp_Object *x, *y;
     unsigned long *time;
{
  FRAME_PTR f1;

  BLOCK_INPUT;

  if (! NILP (last_mouse_scroll_bar))
    x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
  else
    {
      Window root;
      int root_x, root_y;

      mouse_moved = 0;
      last_mouse_scroll_bar = Qnil;

      /* Figure out which root window we're on.  */
      XQueryPointer (FRAME_X_DISPLAY (*fp),
		     DefaultRootWindow (FRAME_X_DISPLAY (*fp)),

		     /* The root window which contains the pointer.  */
		     &root,

		     /* Trash which we can't trust if the pointer is on

	int win_x, win_y;
	int parent_x, parent_y;

	win = root;

	if (FRAME_X_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
	    && FRAME_LIVE_P (last_mouse_frame))
	  {
	    /* If mouse was grabbed on a frame, give coords for that frame
	       even if the mouse is now outside it.  */
	    XTranslateCoordinates (FRAME_X_DISPLAY (*fp),

				   /* From-window, to-window.  */
				   root, FRAME_X_WINDOW (last_mouse_frame),

				   /* From-position, to-position.  */

	  }
	else
	  {
	    while (1)
	      {
		XTranslateCoordinates (FRAME_X_DISPLAY (*fp),

				       /* From-window, to-window.  */
				       root, win,

				       /* From-position, to-position.  */

	    int ignore1, ignore2;

	    /* Ok, we found a frame.  Store all the values.  */

	    pixel_to_glyph_coords (f1, win_x, win_y, &ignore1, &ignore2,
				   &last_mouse_glyph,
				   FRAME_X_DISPLAY_INFO (f1)->grabbed);

	    *bar_window = Qnil;
	    *part = 0;
	    *fp = f1;
	    XSETINT (*x, win_x);
	    XSETINT (*y, win_y);
	    *time = last_mouse_movement_time;
	  }
      }

static struct scroll_bar *
x_scroll_bar_create (window, top, left, width, height)
     struct window *window;
     int top, left, width, height;
{
  FRAME_PTR f = XFRAME (WINDOW_FRAME (window));
  struct scroll_bar *bar
    = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));

  BLOCK_INPUT;

  {
    XSetWindowAttributes a;
    unsigned long mask;
    a.background_pixel = f->display.x->background_pixel;
    a.event_mask = (ButtonPressMask | ButtonReleaseMask
		    | ButtonMotionMask | PointerMotionHintMask
		    | ExposureMask);
    a.cursor = x_vertical_scroll_bar_cursor;

    XtSetArg (al[ac], XtNwidth, width); ac++;
    XtSetArg (al[ac], XtNheight, height); ac++;
    XtSetArg (al[ac], XtNborderWidth, 0); ac++;
    sb_widget = XtCreateManagedWidget ("box",
				       boxWidgetClass,
				       f->display.x->edit_widget, al, ac);
    SET_SCROLL_BAR_X_WINDOW
      (bar, sb_widget->core.window);
#endif
    SET_SCROLL_BAR_X_WINDOW
      (bar,
       XCreateWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),

		      /* Position and size of scroll bar.  */
		      left, top, width, height,

		      /* Border width, depth, class, and visual.  */

  XSETINT (bar->start, 0);
  XSETINT (bar->end, 0);
  bar->dragging = Qnil;

  /* Add bar to its frame's list of scroll bars.  */
  bar->next = FRAME_SCROLL_BARS (f);
  bar->prev = Qnil;
  XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
  if (! NILP (bar->next))
    XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);

  XMapWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));

  UNBLOCK_INPUT;

  return bar;
}

     int start, end;
     int rebuild;
{
  int dragging = ! NILP (bar->dragging);
  Window w = SCROLL_BAR_X_WINDOW (bar);
  FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
  GC gc = f->display.x->normal_gc;

  /* If the display is already accurate, do nothing.  */
  if (! rebuild
      && start == XINT (bar->start)
      && end == XINT (bar->end))

    end += VERTICAL_SCROLL_BAR_MIN_HANDLE;

    /* Draw the empty space above the handle.  Note that we can't clear
       zero-height areas; that means "clear to end of window."  */
    if (0 < start)
      XClearArea (FRAME_X_DISPLAY (f), w,

		  /* x, y, width, height, and exposures.  */
		  VERTICAL_SCROLL_BAR_LEFT_BORDER,
		  VERTICAL_SCROLL_BAR_TOP_BORDER,
		  inside_width, start,
		  False);

    /* Draw the handle itself.  */
    XFillRectangle (FRAME_X_DISPLAY (f), w, gc,

		    /* x, y, width, height */
		    VERTICAL_SCROLL_BAR_LEFT_BORDER,
		    VERTICAL_SCROLL_BAR_TOP_BORDER + start,
		    inside_width, end - start);


    /* Draw the empty space below the handle.  Note that we can't
       clear zero-height areas; that means "clear to end of window." */
    if (end < inside_height)
      XClearArea (FRAME_X_DISPLAY (f), w,

		  /* x, y, width, height, and exposures.  */
		  VERTICAL_SCROLL_BAR_LEFT_BORDER,
		  VERTICAL_SCROLL_BAR_TOP_BORDER + end,
		  inside_width, inside_height - end,

static void
x_scroll_bar_move (bar, top, left, width, height)
     struct scroll_bar *bar;
     int top, left, width, height;
{
  Window w = SCROLL_BAR_X_WINDOW (bar);
  FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));

  BLOCK_INPUT;

  {
    XWindowChanges wc;
    unsigned int mask = 0;

    if (top != XINT (bar->top))		mask |= CWY;
    if (width != XINT (bar->width))	mask |= CWWidth;
    if (height != XINT (bar->height))	mask |= CWHeight;

    if (mask)
      XConfigureWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar),
			mask, &wc);
  }

  XSETINT (bar->left, left);
  XSETINT (bar->top, top);

  FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));

  BLOCK_INPUT;

  /* Destroy the window.  */
  XDestroyWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));

  /* Disassociate this scroll bar from its window.  */
  XWINDOW (bar->window)->vertical_scroll_bar = Qnil;

  UNBLOCK_INPUT;

x_scroll_bar_expose (bar, event)
     struct scroll_bar *bar;
     XEvent *event;
{
  Window w = SCROLL_BAR_X_WINDOW (bar);
  FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
  GC gc = f->display.x->normal_gc;

  BLOCK_INPUT;

  x_scroll_bar_set_handle (bar, XINT (bar->start), XINT (bar->end), 1);

  /* Draw a one-pixel border just inside the edges of the scroll bar. */
  XDrawRectangle (FRAME_X_DISPLAY (f), w, gc,

		  /* x, y, width, height */
		  0, 0, XINT (bar->width) - 1, XINT (bar->height) - 1);

  UNBLOCK_INPUT;

    abort ();

  emacs_event->kind = scroll_bar_click;
  emacs_event->code = event->xbutton.button - Button1;
  emacs_event->modifiers =
    (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))),
			     event->xbutton.state)
     | (event->type == ButtonRelease
	? up_modifier
	: down_modifier));
  emacs_event->frame_or_window = bar->window;
  emacs_event->timestamp = event->xbutton.time;

}

/* Return information to the user about the current position of the mouse
   on the scroll bar.  */
static void
x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
     FRAME_PTR *fp;
     Lisp_Object *bar_window;
     enum scroll_bar_part *part;
     Lisp_Object *x, *y;
     unsigned long *time;
{
  struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
  Window w = SCROLL_BAR_X_WINDOW (bar);
  FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
  int win_x, win_y;
  Window dummy_window;
  int dummy_coord;
  unsigned int dummy_mask;

  BLOCK_INPUT;

  /* Get the mouse's position relative to the scroll bar window, and
     report that.  */
  if (! XQueryPointer (FRAME_X_DISPLAY (f), w,

		       /* Root, child, root x and root y.  */
		       &dummy_window, &dummy_window,
		       &dummy_coord, &dummy_coord,

		       /* Position relative to scroll bar.  */
		       &win_x, &win_y,

		       /* Mouse buttons and modifier keys.  */
		       &dummy_mask))
    *fp = 0;
  else
    {
      int inside_height
	= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar->height));
      int top_range

      if (win_y < 0)
	win_y = 0;
      if (win_y > top_range)
	win_y = top_range;

      *fp = f;
      *bar_window = w;

      if (! NILP (bar->dragging))
	*part = scroll_bar_handle;
      else if (win_y < XINT (bar->start))
	*part = scroll_bar_above_handle;

{
  Lisp_Object bar;

  for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
       bar = XSCROLL_BAR (bar)->next)
    XClearArea (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)),
		0, 0, 0, 0, True);
}

/* This processes Expose events from the menubar specific X event
   loop in menubar.c.  This allows to redisplay the frame if necessary

static int x_queue_selection_requests;

/* Queue up an X event *EVENT, to be processed later.  */

static void
x_queue_event (f, event)
     FRAME_PTR f;
     XEvent *event;
{
  struct selection_event_queue *queue_tmp
    = (struct selection_event_queue *) malloc (sizeof (struct selection_event_queue));

/* Take all the queued events and put them back
   so that they get processed afresh.  */

static void
x_unqueue_events (f)
     FRAME_PTR f;
{
  while (queue != NULL)
    {
      struct selection_event_queue *queue_tmp = queue;
      XPutBackEvent (FRAME_X_DISPLAY (f), &queue_tmp->event);
      queue = queue_tmp->next;
      free ((char *)queue_tmp);
    }
}

/* Start queuing SelectionRequest events.  */

void
x_start_queuing_selection_requests (f)
     FRAME_PTR f;
{
  x_queue_selection_requests++;
}

/* Stop queuing SelectionRequest events.  */

void
x_stop_queuing_selection_requests (f)
     FRAME_PTR f;
{
  x_queue_selection_requests--;
  x_unqueue_events (f);
}

/* The main X event-reading loop - XTread_socket.  */

/* Timestamp of enter window event.  This is only used by XTread_socket,

   me that letting the compiler initialize it to zeros will work okay.

   This must be defined outside of XTread_socket, for the same reasons
   given for enter_timestamp, above.  */
static XComposeStatus compose_status;

/* Record the last 100 characters stored
   to help debug the loss-of-chars-during-GC problem.  */
int temp_index;
short temp_buffer[100];

  XEvent event;
  struct frame *f;
  int event_found = 0;
  int prefix;
  Lisp_Object part;
  struct x_display_info *dpyinfo;

  if (interrupt_input_blocked)
    {
      interrupt_input_pending = 1;
      return -1;
    }

  interrupt_input_pending = 0;
  BLOCK_INPUT;

  /* Find the display we are supposed to read input for.
     It's the one communicating on descriptor SD.  */
  for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
    if (dpyinfo->connection == sd)
      break;
  if (dpyinfo == 0)
    abort ();

  /* So people can tell when we have read the available input.  */
  input_signal_count++;

  if (numchars <= 0)

#ifdef FIOSNBIO
  /* If available, Xlib uses FIOSNBIO to make the socket
     non-blocking, and then looks for EWOULDBLOCK.  If O_NDELAY is set,
     FIOSNBIO is ignored, and instead of signalling EWOULDBLOCK,
     a read returns 0, which Xlib interprets as equivalent to EPIPE. */
  fcntl (sd, F_SETFL, 0);
#endif /* ! defined (FIOSNBIO) */

#ifndef SIGIO
#ifndef HAVE_SELECT
  if (! (fcntl (sd, F_GETFL, 0) & O_NDELAY))
    {
      extern int read_alarm_should_throw;
      read_alarm_should_throw = 1;
      XPeekEvent (dpyinfo->display, &event);
      read_alarm_should_throw = 0;
    }
#endif /* HAVE_SELECT */
#endif /* SIGIO */

  while (XPending (dpyinfo->display) != 0)
    {
      XNextEvent (dpyinfo->display, &event);
      event_found = 1;

      switch (event.type)
	{
	case ClientMessage:
	  {
	    if (event.xclient.message_type
		== dpyinfo->Xatom_wm_protocols
		&& event.xclient.format == 32)
	      {
		if (event.xclient.data.l[0]
		    == dpyinfo->Xatom_wm_take_focus)
		  {
		    f = x_window_to_frame (event.xclient.window);
		    /* Since we set WM_TAKE_FOCUS, we must call
		       XSetInputFocus explicitly.  But not if f is null,
		       since that might be an event for a deleted frame.  */

				      event.xclient.window,
				      RevertToPointerRoot,
				      event.xclient.data.l[1]);
		    /* Not certain about handling scroll bars here */
		  }
		else if (event.xclient.data.l[0]
			 == dpyinfo->Xatom_wm_save_yourself)
		  {
		    /* Save state modify the WM_COMMAND property to
		       something which can reinstate us. This notifies
		       the session manager, who's looking for such a
		       PropertyNotify.  Can restart processing when
		       a keyboard or mouse event arrives. */
		    if (numchars > 0)
		      {
			f = x_top_window_to_frame (event.xclient.window);

			/* This is just so we only give real data once
			   for a single Emacs process.  */
			if (f == selected_frame)
			  XSetCommand (FRAME_X_DISPLAY (f),
				       event.xclient.window,
				       initial_argv, initial_argc);
			else
			  XSetCommand (FRAME_X_DISPLAY (f),
				       event.xclient.window,
				       0, 0);
		      }
		  }
		else if (event.xclient.data.l[0]
			 == dpyinfo->Xatom_wm_delete_window)
		  {
		    struct frame *f = x_any_window_to_frame (event.xclient.window);

		    if (f)
		      {

			count += 1;
			numchars -= 1;
		      }
		  }
	      }
	    else if (event.xclient.message_type
		     == dpyinfo->Xatom_wm_configure_denied)
	      {
	      }
	    else if (event.xclient.message_type
		     == dpyinfo->Xatom_wm_window_moved)
	      {
		int new_x, new_y;
		struct frame *f = x_window_to_frame (event.xclient.window);

		new_x = event.xclient.data.s[0];

		    f->display.x->left_pos = new_x;
		    f->display.x->top_pos = new_y;
		  }
	      }
#if defined (USE_X_TOOLKIT) && defined (HAVE_X11R5)
	    else if (event.xclient.message_type
		     == dpyinfo->Xatom_editres)
	      {
		struct frame *f = x_any_window_to_frame (event.xclient.window);
		_XEditResCheckMessages (f->display.x->widget, NULL, &event, NULL);
	      }
#endif /* USE_X_TOOLKIT and HAVE_X11R5 */

#ifdef USE_X_TOOLKIT
	  if (!x_window_to_frame (event.xselectionrequest.owner))
	    goto OTHER;
#endif /* USE_X_TOOLKIT */
	  if (x_queue_selection_requests)
	    x_queue_event (x_window_to_frame (event.xselectionrequest.owner),
			   &event);
	  else
	    {
	      XSelectionRequestEvent *eventp = (XSelectionRequestEvent *) &event;

	      if (numchars == 0)

		 80 fixed a bug whereby meta chars made his Emacs hang.  */
	      unsigned char copy_buffer[81];
	      int modifiers;

	      event.xkey.state
		|= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f),
					   extra_keyboard_modifiers);
	      modifiers = event.xkey.state;

	      /* This will have to go some day...  */

	      /* make_lispy_event turns chars into control chars.

			temp_index = 0;
		      temp_buffer[temp_index++] = keysym;
		      bufp->kind = non_ascii_keystroke;
		      bufp->code = keysym;
		      XSETFRAME (bufp->frame_or_window, f);
		      bufp->modifiers
			= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
						  modifiers);
		      bufp->timestamp = event.xkey.time;
		      bufp++;
		      count++;
		      numchars--;
		    }

			    temp_index = 0;
			  temp_buffer[temp_index++] = copy_buffer[i];
			  bufp->kind = ascii_keystroke;
			  bufp->code = copy_buffer[i];
			  XSETFRAME (bufp->frame_or_window, f);
			  bufp->modifiers
			    = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
						      modifiers);
			  bufp->timestamp = event.xkey.time;
			  bufp++;
			}

		      count += nbytes;

#endif /* USE_X_TOOLKIT */
	  break;

	case MotionNotify:
	  {
	    if (dpyinfo->grabbed && last_mouse_frame
		&& FRAME_LIVE_P (last_mouse_frame))
	      f = last_mouse_frame;
	    else
	      f = x_window_to_frame (event.xmotion.window);
	    if (f)

              /* Find the position of the outside upper-left corner of
                 the window, in the root coordinate system.  Don't
                 refer to the parent window here; we may be processing
                 this event after the window manager has changed our
                 parent, but before we have reached the ReparentNotify.  */
              XTranslateCoordinates (FRAME_X_DISPLAY (f),

                                     /* From-window, to-window.  */
                                     XtWindow (f->display.x->widget),
                                     FRAME_X_DISPLAY_INFO (f)->root_window,

                                     /* From-position, to-position.  */
                                     -event.xconfigure.border_width,
                                     -event.xconfigure.border_width,
                                     &win_x, &win_y,

		  /* Find the position of the outside upper-left corner of
		     the window, in the root coordinate system.  Don't
		     refer to the parent window here; we may be processing
		     this event after the window manager has changed our
		     parent, but before we have reached the ReparentNotify.  */
		  XTranslateCoordinates (FRAME_X_DISPLAY (f),

					 /* From-window, to-window.  */
					 f->display.x->window_desc,
					 FRAME_X_DISPLAY_INFO (f)->root_window,

					 /* From-position, to-position.  */
					 -event.xconfigure.border_width,
					 -event.xconfigure.border_width,
					 &win_x, &win_y,

#endif /* USE_X_TOOLKIT */
	      }

	    if (event.type == ButtonPress)
	      {
		dpyinfo->grabbed |= (1 << event.xbutton.button);
		last_mouse_frame = f;
	      }
	    else
	      {
		dpyinfo->grabbed &= ~(1 << event.xbutton.button);
	      }

	    if (numchars >= 1 && emacs_event.kind != no_event)
	      {
		bcopy (&emacs_event, bufp, sizeof (struct input_event));

	  /* Someone has changed the keyboard mapping - update the
	     local cache.  */
	  switch (event.xmapping.request)
	    {
	    case MappingModifier:
	      x_find_modifier_meanings (dpyinfo);
	      /* This is meant to fall through.  */
	    case MappingKeyboard:
	      XRefreshKeyboardMapping (&event.xmapping);
	    }
#ifdef USE_X_TOOLKIT

	 B. Bretthauer, 1994 */
      x_noop_count++;
      if (x_noop_count >= 100)
	{
	  x_noop_count=0;
	  XNoOp (dpyinfo->display);
	}
    }

#if 0 /* This fails for serial-line connections to the X server,
	 because the characters arrive one by one, and a partial

  if (expected && ! event_found)
    {
      /* AOJ 880406: if select returns true but XPending doesn't, it means that
	 there is an EOF condition; in other words, that X has died.
	 Act as if there had been a hangup. */
      int fd = ConnectionNumber (dpyinfo->display);
      SELECT_TYPE mask, junk1, junk2;
      EMACS_TIME timeout;

      FD_ZERO (&mask);
      FD_SET (fd, &mask);
      EMACS_SET_SECS_USECS (timeout, 0, 0);
      FD_ZERO (&junk1);
      FD_ZERO (&junk2);
      if (0 != select (fd + 1, &mask, &junk1, &junk2, &timeout)
	  && !XPending (dpyinfo->display))
	kill (getpid (), SIGHUP);
    }
#endif /* HAVE_SELECT */
#endif /* 0 */

  int left = CHAR_TO_PIXEL_COL (f, curs_x);
  int top  = CHAR_TO_PIXEL_ROW (f, curs_y);
  int width = FONT_WIDTH (f->display.x->font);
  int height = f->display.x->line_height;

  XDrawRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		  f->display.x->cursor_gc,
		  left, top, width - 1, height - 1);
}

/* Clear the cursor of frame F to background color,

      f->phys_cursor_glyph
	= ((current_glyphs->enable[curs_y]
	    && curs_x < current_glyphs->used[curs_y])
	   ? current_glyphs->glyphs[curs_y][curs_x]
	   : SPACEGLYPH);
      XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		      f->display.x->cursor_gc,
		      CHAR_TO_PIXEL_COL (f, curs_x),
		      CHAR_TO_PIXEL_ROW (f, curs_y),
		      1, f->display.x->line_height);

      f->display.x->current_cursor = bar_cursor;
    }

  if (updating_frame != f)
    XFlush (FRAME_X_DISPLAY (f));
}


/* Turn the displayed cursor of frame F on or off according to ON.
   If ON is nonzero, where to put the cursor is specified

	mouse_face_here = 1;

      /* If the font is not as tall as a whole line,
	 we must explicitly clear the line's whole height.  */
      if (FONT_HEIGHT (f->display.x->font) != f->display.x->line_height)
	XClearArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		    CHAR_TO_PIXEL_COL (f, f->phys_cursor_x),
		    CHAR_TO_PIXEL_ROW (f, f->phys_cursor_y),
		    FONT_WIDTH (f->display.x->font),
		    f->display.x->line_height, False);
      /* Erase the cursor by redrawing the character underneath it.  */

      f->phys_cursor_x = curs_x;
      f->phys_cursor_y = curs_y;
    }

  if (updating_frame != f)
    XFlush (FRAME_X_DISPLAY (f));
}

x_display_cursor (f, on)
     struct frame *f;
     int on;

  if (STRINGP (file))
    bitmap_id = x_create_bitmap_from_file (f, file);
  else
    {
      /* Create the GNU bitmap if necessary.  */
      if (!FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id < 0)
	FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id
	  = x_create_bitmap_from_data (f, gnu_bits,
				       gnu_width, gnu_height);

      /* The first time we create the GNU bitmap,
	 this increments the refcount one extra time.
	 As a result, the GNU bitmap is never freed.
	 That way, we don't have to worry about allocating it again.  */
      x_reference_bitmap (f, FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id);

      bitmap_id = FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id;
    }

  x_wm_set_icon_pixmap (f, bitmap_id);
  f->display.x->icon_bitmap = bitmap_id;

  else
    if (! f->display.x->icon_label)
      f->display.x->icon_label = " *emacs* ";

#if 0
  XSetIconName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		(char *) f->display.x->icon_label);
#endif

  if (f->display.x->icon_bitmap > 0)
    x_destroy_bitmap (f, f->display.x->icon_bitmap);

  XGetErrorText (display, error->error_code,
		 x_caught_error_message, X_CAUGHT_ERROR_MESSAGE_SIZE);
}


/* Begin trapping X errors for frame F.
   Actually we trap X errors for all frames, but F should be the frame
   you are actually operating on.

   After calling this function, X protocol errors no longer cause
   Emacs to exit; instead, they are recorded in x_cfc_error_message.

   Calling x_check_errors signals an Emacs error if an X error has

   Calling x_uncatch_errors resumes the normal error handling.  */

void x_catch_errors (), x_check_errors (), x_uncatch_errors ();

void
x_catch_errors (f)
     FRAME_PTR f;
{
  /* Make sure any errors from previous requests have been dealt with.  */
  XSync (FRAME_X_DISPLAY (f), False);

  /* Set up the error buffer.  */
  x_caught_error_message
    = (char*) xmalloc (X_CAUGHT_ERROR_MESSAGE_SIZE);
  x_caught_error_message[0] = '\0';

  /* Install our little error handler.  */
  XSetErrorHandler (x_error_catcher);
}

/* If any X protocol errors have arrived since the last call to
   x_catch_errors or x_check_errors, signal an Emacs error using
   sprintf (a buffer, FORMAT, the x error message text) as the text.  */

void
x_check_errors (f, format)
     FRAME_PTR f;
     char *format;
{
  /* Make sure to catch any errors incurred so far.  */
  XSync (FRAME_X_DISPLAY (f), False);

  if (x_caught_error_message[0])
    {
      char buf[X_CAUGHT_ERROR_MESSAGE_SIZE + 56];

      sprintf (buf, format, x_caught_error_message);
      x_uncatch_errors (f);
      error (buf);
    }
}

/* Nonzero if we had any X protocol errors since we did x_catch_errors.  */

int
x_had_errors_p (f)
     FRAME_PTR f;
{
  /* Make sure to catch any errors incurred so far.  */
  XSync (FRAME_X_DISPLAY (f), False);

  return x_caught_error_message[0] != 0;
}

/* Stop catching X protocol errors and let them make Emacs die.  */

void
x_uncatch_errors (f)
     FRAME_PTR f;
{
  xfree (x_caught_error_message);
  x_caught_error_message = 0;
  XSetErrorHandler (x_error_quitter);
}

#if 0
static unsigned int x_wire_count;
x_trace_wire ()

  char **font_names;

  /* Get a list of all the fonts that match this name.  Once we
     have a list of matching fonts, we compare them against the fonts
     we already have by comparing font ids.  */
  font_names = (char **) XListFonts (FRAME_X_DISPLAY (f), fontname,
				     1024, &n_matching_fonts);
  /* Apparently it doesn't set n_matching_fonts to zero when it can't
     find any matches; font_names == 0 is the only clue.  */
  if (! font_names)
    n_matching_fonts = 0;

      /* See comment above.  */
      if (n_matching_fonts != 0)
	fontname = font_names[i];

      font = (XFontStruct *) XLoadQueryFont (FRAME_X_DISPLAY (f), fontname);
      if (! font)
	{
	  /* Free the information from XListFonts.  */
	  if (n_matching_fonts)
	    XFreeFontNames (font_names);

      /* Try to get the full name of FONT.  Put it in full_name.  */
      full_name = 0;
      for (i = 0; i < font->n_properties; i++)
	{
	  char *atom
	    = XGetAtomName (FRAME_X_DISPLAY (f), font->properties[i].name);
	  if (!strcmp (atom, "FONT"))
	    {
	      char *name = XGetAtomName (FRAME_X_DISPLAY (f),
					 (Atom) (font->properties[i].card32));
	      char *p = name;
	      int dashes = 0;

	      /* Count the number of dashes in the "full name".

    f->scroll_bar_cols = 2;

  /* Now make the frame display the given font.  */
  if (FRAME_X_WINDOW (f) != 0)
    {
      XSetFont (FRAME_X_DISPLAY (f), f->display.x->normal_gc,
		f->display.x->font->fid);
      XSetFont (FRAME_X_DISPLAY (f), f->display.x->reverse_gc,
		f->display.x->font->fid);
      XSetFont (FRAME_X_DISPLAY (f), f->display.x->cursor_gc,
		f->display.x->font->fid);

      frame_update_line_height (f);
      x_set_window_size (f, 0, f->width, f->height);
    }

  int win_x = 0, win_y = 0;
  int flags = f->display.x->size_hint_flags;

  /* Find the position of the outside upper-left corner of
     the inner window, with respect to the outer window.  */
  if (f->display.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
    {
      BLOCK_INPUT;
      XTranslateCoordinates (FRAME_X_DISPLAY (f),

			     /* From-window, to-window.  */
			     f->display.x->window_desc,
			     f->display.x->parent_desc,

    }

  /* Treat negative positions as relative to the leftmost bottommost
     position that fits on the screen.  */
  if (flags & XNegative)
    f->display.x->left_pos = (FRAME_X_DISPLAY_INFO (f)->width
			      - 2 * f->display.x->border_width - win_x
			      - PIXEL_WIDTH (f)
			      + f->display.x->left_pos);

  if (flags & YNegative)
    f->display.x->top_pos = (FRAME_X_DISPLAY_INFO (f)->height
			     - 2 * f->display.x->border_width - win_y
			     - PIXEL_HEIGHT (f)
			     + f->display.x->top_pos);
  /* The left_pos and top_pos
     are now relative to the top and left screen edges,

  BLOCK_INPUT;
  x_wm_set_size_hint (f, 0, 0);

#ifdef USE_X_TOOLKIT
  XMoveWindow (FRAME_X_DISPLAY (f), XtWindow (f->display.x->widget),
	       f->display.x->left_pos, f->display.x->top_pos);
#else /* not USE_X_TOOLKIT */
  XMoveWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
	       f->display.x->left_pos, f->display.x->top_pos);
#endif /* not USE_X_TOOLKIT */
  UNBLOCK_INPUT;
}

  pixelheight = CHAR_TO_PIXEL_HEIGHT (f, rows);

  f->display.x->win_gravity = NorthWestGravity;
  x_wm_set_size_hint (f, 0, 0);

  XSync (FRAME_X_DISPLAY (f), False);
  XResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		 pixelwidth, pixelheight);

  /* Now, strictly speaking, we can't be sure that this is accurate,
     but the window manager will get around to dealing with the size
     change request eventually, and we'll hear how it went when the
     ConfigureNotify event gets here.

     receive in the ConfigureNotify event; if we get what we asked
     for, then the event won't cause the screen to become garbaged, so
     we have to make sure to do it here.  */
  SET_FRAME_GARBAGED (f);

  XFlush (FRAME_X_DISPLAY (f));
  UNBLOCK_INPUT;
#endif /* not USE_X_TOOLKIT */
}

/* Mouse warping, focus shifting, raising and lowering.  */

  if (pix_y < 0) pix_y = 0;
  if (pix_y > PIXEL_HEIGHT (f)) pix_y = PIXEL_HEIGHT (f);

  BLOCK_INPUT;

  XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
		0, 0, 0, 0, pix_x, pix_y);
  UNBLOCK_INPUT;
}

/* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F.  */

     struct frame *f;
     int pix_x, pix_y;
{
  BLOCK_INPUT;

  XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
		0, 0, 0, 0, pix_x, pix_y);
  UNBLOCK_INPUT;
}

x_focus_on_frame (f)
     struct frame *f;

#endif
#if 0
  /* I don't think that the ICCCM allows programs to do things like this
     without the interaction of the window manager.  Whatever you end up
     doing with this code, do it to x_unfocus_frame too.  */
  XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
		  RevertToPointerRoot, CurrentTime);
#endif /* ! 0 */
}

x_unfocus_frame (f)
     struct frame *f;
{
#if 0
  /* Look at the remarks in x_focus_on_frame.  */
  if (x_focus_frame == f)
    XSetInputFocus (FRAME_X_DISPLAY (f), PointerRoot,
		    RevertToPointerRoot, CurrentTime);
#endif /* ! 0 */
}

/* Raise frame F.  */

{
  if (f->async_visible)
    {
      BLOCK_INPUT;
#ifdef USE_X_TOOLKIT
      XRaiseWindow (FRAME_X_DISPLAY (f), XtWindow (f->display.x->widget));
#else /* not USE_X_TOOLKIT */
      XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif /* not USE_X_TOOLKIT */
      XFlush (FRAME_X_DISPLAY (f));
      UNBLOCK_INPUT;
    }
}

/* Lower frame F.  */

{
  if (f->async_visible)
    {
      BLOCK_INPUT;
#ifdef USE_X_TOOLKIT
      XLowerWindow (FRAME_X_DISPLAY (f), XtWindow (f->display.x->widget));
#else /* not USE_X_TOOLKIT */
      XLowerWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif /* not USE_X_TOOLKIT */
      XFlush (FRAME_X_DISPLAY (f));
      UNBLOCK_INPUT;
    }
}

static void

	x_wm_set_window_state (f, NormalState);
#ifdef USE_X_TOOLKIT
      /* This was XtPopup, but that did nothing for an iconified frame.  */
      XtMapWidget (f->display.x->widget);
#else /* not USE_X_TOOLKIT */
      XMapWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif /* not USE_X_TOOLKIT */
#if 0 /* This seems to bring back scroll bars in the wrong places
	 if the window configuration has changed.  They seem
	 to come back ok without this.  */
      if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
	XMapSubwindows (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif
    }

  XFlush (FRAME_X_DISPLAY (f));

  /* Synchronize to ensure Emacs knows the frame is visible
     before we do anything else.  We do this loop with input not blocked
     so that incoming events are handled.  */
  {

    XSETFRAME (frame, f);

    while (1)
      {
	x_sync (f);
	/* Once we have handled input events,
	   we should have received the MapNotify if one is coming.
	   So if we have not got it yet, stop looping.
	   Some window managers make their own decisions
	   about visibility.  */

     by hand again (they have already done that once for this window.)  */
  x_wm_set_size_hint (f, 0, 1);

#ifdef HAVE_X11R4

  if (! XWithdrawWindow (FRAME_X_DISPLAY (f), window,
			 DefaultScreen (FRAME_X_DISPLAY (f))))
    {
      UNBLOCK_INPUT_RESIGNAL;
      error ("Can't notify window manager of window withdrawal");
    }
#else /* ! defined (HAVE_X11R4) */

    {
      XEvent unmap;

      unmap.xunmap.type = UnmapNotify;
      unmap.xunmap.window = window;
      unmap.xunmap.event = DefaultRootWindow (FRAME_X_DISPLAY (f));
      unmap.xunmap.from_configure = False;
      if (! XSendEvent (FRAME_X_DISPLAY (f),
			DefaultRootWindow (FRAME_X_DISPLAY (f)),
			False,
			SubstructureRedirectMask|SubstructureNotifyMask,
			&unmap))
	{
	  UNBLOCK_INPUT_RESIGNAL;
	  error ("Can't notify window manager of withdrawal");
	}
    }

  /* Unmap the window ourselves.  Cheeky!  */
  XUnmapWindow (FRAME_X_DISPLAY (f), window);
#endif /* ! defined (HAVE_X11R4) */

  /* We can't distinguish this from iconification
     just by the event that we get from the server.
     So we can't win using the usual strategy of letting

  f->visible = 0;
  FRAME_ICONIFIED_P (f) = 0;
  f->async_visible = 0;
  f->async_iconified = 0;

  x_sync (f);

  UNBLOCK_INPUT;
}

/* Change window state from mapped to iconified. */

      XtMapWidget (f->display.x->widget);
      UNBLOCK_INPUT;
      return;
    }

  result = XIconifyWindow (FRAME_X_DISPLAY (f),
			   XtWindow (f->display.x->widget),
			   DefaultScreen (FRAME_X_DISPLAY (f)));
  UNBLOCK_INPUT;

  if (!result)
    error ("Can't notify window manager of iconification");

  f->async_iconified = 1;

  BLOCK_INPUT;
  XFlush (FRAME_X_DISPLAY (f));
  UNBLOCK_INPUT;
#else /* not USE_X_TOOLKIT */

  /* Make sure the X server knows where the window should be positioned,
     in case the user deiconifies with the window manager.  */

  {
    XEvent message;

    message.xclient.window = FRAME_X_WINDOW (f);
    message.xclient.type = ClientMessage;
    message.xclient.message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_change_state;
    message.xclient.format = 32;
    message.xclient.data.l[0] = IconicState;

    if (! XSendEvent (FRAME_X_DISPLAY (f),
		      DefaultRootWindow (FRAME_X_DISPLAY (f)),
		      False,
		      SubstructureRedirectMask | SubstructureNotifyMask,
		      &message))
      {
	UNBLOCK_INPUT_RESIGNAL;

  x_wm_set_window_state (f, IconicState);

  if (!FRAME_VISIBLE_P (f))
    {
      /* If the frame was withdrawn, before, we must map it.  */
      XMapWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#if 0 /* We don't have subwindows in the icon.  */
      if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
	XMapSubwindows (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
#endif
    }

  f->async_iconified = 1;

  XFlush (FRAME_X_DISPLAY (f));
  UNBLOCK_INPUT;
#endif /* not USE_X_TOOLKIT */
}

/* Destroy the X window of frame F.  */

     struct frame *f;
{
  BLOCK_INPUT;

  if (f->display.x->icon_desc != 0)
    XDestroyWindow (FRAME_X_DISPLAY (f), f->display.x->icon_desc);
  XDestroyWindow (FRAME_X_DISPLAY (f), f->display.x->window_desc);
#ifdef USE_X_TOOLKIT
  XtDestroyWidget (f->display.x->widget);
  free_frame_menubar (f);
#endif /* USE_X_TOOLKIT */

  free_frame_faces (f);
  XFlush (FRAME_X_DISPLAY (f));

  FRAME_X_DISPLAY_INFO (f)->reference_count--;
#if 0
  if (FRAME_X_DISPLAY_INFO (f)->reference_count == 0)
    free (FRAME_X_DISPLAY_INFO (f));
#endif

  xfree (f->display.x);
  f->display.x = 0;
  if (f == x_focus_frame)

  size_hints.width = PIXEL_WIDTH (f);
#endif /* not USE_X_TOOLKIT */

  size_hints.width_inc = FONT_WIDTH (f->display.x->font);
  size_hints.height_inc = f->display.x->line_height;
  size_hints.max_width
    = FRAME_X_DISPLAY_INFO (f)->width - CHAR_TO_PIXEL_WIDTH (f, 0);
  size_hints.max_height
    = FRAME_X_DISPLAY_INFO (f)->height - CHAR_TO_PIXEL_HEIGHT (f, 0);

  {
    int base_width, base_height;
    int min_rows = 0, min_cols = 0;

      XSizeHints hints;		/* Sometimes I hate X Windows... */
      long supplied_return;
      int value;

#ifdef HAVE_X11R4
      value = XGetWMNormalHints (FRAME_X_DISPLAY (f), window, &hints,
				 &supplied_return);
#else
      value = XGetNormalHints (FRAME_X_DISPLAY (f), window, &hints);
#endif

      if (value == 0)
	hints.flags = 0;
      if (hints.flags & PSize)

      size_hints.flags |= USPosition;
    }
#endif /* PWinGravity */

#ifdef HAVE_X11R4
  XSetWMNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
#else
  XSetNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
#endif
}

/* Used for IconicState or NormalState */
x_wm_set_window_state (f, state)

  Window window = FRAME_X_WINDOW (f);

  f->display.x->wm_hints.flags |= StateHint;
  f->display.x->wm_hints.initial_state = state;

  XSetWMHints (FRAME_X_DISPLAY (f), window, &f->display.x->wm_hints);
#endif /* not USE_X_TOOLKIT */
}

x_wm_set_icon_pixmap (f, pixmap_id)
     struct frame *f;

    {
      f->display.x->wm_hints.icon_pixmap = None;
      f->display.x->wm_hints.flags &= ~IconPixmapHint;
    }

  XSetWMHints (FRAME_X_DISPLAY (f), window, &f->display.x->wm_hints);
}

x_wm_set_icon_position (f, icon_x, icon_y)
     struct frame *f;
     int icon_x, icon_y;

  f->display.x->wm_hints.flags |= IconPositionHint;
  f->display.x->wm_hints.icon_x = icon_x;
  f->display.x->wm_hints.icon_y = icon_y;

  XSetWMHints (FRAME_X_DISPLAY (f), window, &f->display.x->wm_hints);
}


/* Initialization.  */

  {"-mc",	"*pointerColor", XrmoptionSepArg, (XtPointer) NULL},
  {"-cr",	"*cursorColor", XrmoptionSepArg, (XtPointer) NULL}
};
#endif /* USE_X_TOOLKIT */

struct x_display_info *
x_term_init (display_name, xrm_option, resource_name)
     Lisp_Object display_name;
     char *xrm_option;
     char *resource_name;
{
  Lisp_Object frame;
  char *defaultvalue;
  int argc = 0;
  char** argv = 0;
  int connection;
  struct x_display_info *dpyinfo;
  XrmDatabase xrdb;

#ifndef F_SETOWN_BUG
#ifdef F_SETOWN
  extern int old_fcntl_owner;
#endif /* ! defined (F_SETOWN) */
#endif /* F_SETOWN_BUG */

  dpyinfo = &the_x_screen;

  /* Put our one and only display on the chain.  */
  x_display_list = dpyinfo;
  dpyinfo->next = 0;

  dpyinfo->name = display_name;

  x_noop_count = 0;

  x_focus_frame = x_highlight_frame = 0;

#ifdef USE_X_TOOLKIT

#endif

  argv = (char **) XtMalloc (7 * sizeof (char *));
  argv[0] = "";
  argv[1] = "-display";
  argv[2] = XSTRING (display_name)->data;
  argv[3] = "-name";
  /* Usually `emacs', but not always.  */
  argv[4] = resource_name;
  argc = 5;
  if (xrm_option)

  Xt_app_shell = XtAppInitialize (&Xt_app_con, "Emacs",
				  emacs_options, XtNumber (emacs_options),
				  &argc, argv,
				  NULL, NULL, 0);
  XtFree ((char *)argv);
  dpyinfo->display = XtDisplay (Xt_app_shell);

#else /* not USE_X_TOOLKIT */
#ifdef HAVE_X11R5
  XSetLocaleModifiers ("");
#endif
  dpyinfo->display = XOpenDisplay (XSTRING (display_name)->data);
#endif /* not USE_X_TOOLKIT */

  if (dpyinfo->display == 0)
    fatal ("X server %s not responding.\n\
Check the DISPLAY environment variable or use \"-d\"\n",
	   XSTRING (display_name)->data);

  {
#if 0
    XSetAfterFunction (x_current_display, x_trace_wire);
#endif /* ! 0 */

    sprintf (x_id_name, "%s@%s",
	     XSTRING (Vinvocation_name)->data, XSTRING (Vsystem_name)->data);
  }

  /* Figure out which modifier bits mean what.  */
  x_find_modifier_meanings (dpyinfo);

  /* Get the scroll bar cursor.  */
  x_vertical_scroll_bar_cursor
    = XCreateFontCursor (dpyinfo->display, XC_sb_v_double_arrow);

#if 0
  /* Watch for PropertyNotify events on the root window; we use them
     to figure out when to invalidate our cache of the cut buffers.  */
  x_watch_cut_buffer_cache ();
#endif

  xrdb = x_load_resources (dpyinfo->display, xrm_option,
			   resource_name, EMACS_CLASS);
#ifdef HAVE_XRMSETDATABASE
  XrmSetDatabase (dpyinfo->display, xrdb);
#else
  dpyinfo->display->db = xrdb;
#endif

  dpyinfo->screen = ScreenOfDisplay (dpyinfo->display,
				     DefaultScreen (dpyinfo->display));
  dpyinfo->visual = select_visual (dpyinfo->display, dpyinfo->screen,
				   &dpyinfo->n_planes);
  dpyinfo->height = HeightOfScreen (dpyinfo->screen);
  dpyinfo->width = WidthOfScreen (dpyinfo->screen);
  dpyinfo->root_window = RootWindowOfScreen (dpyinfo->screen);
  dpyinfo->grabbed = 0;
  dpyinfo->reference_count = 0;
  dpyinfo->icon_bitmap_id = -1;

  dpyinfo->Xatom_wm_protocols
    = XInternAtom (dpyinfo->display, "WM_PROTOCOLS", False);
  dpyinfo->Xatom_wm_take_focus
    = XInternAtom (dpyinfo->display, "WM_TAKE_FOCUS", False);
  dpyinfo->Xatom_wm_save_yourself
    = XInternAtom (dpyinfo->display, "WM_SAVE_YOURSELF", False);
  dpyinfo->Xatom_wm_delete_window
    = XInternAtom (dpyinfo->display, "WM_DELETE_WINDOW", False);
  dpyinfo->Xatom_wm_change_state
    = XInternAtom (dpyinfo->display, "WM_CHANGE_STATE", False);
  dpyinfo->Xatom_wm_configure_denied
    = XInternAtom (dpyinfo->display, "WM_CONFIGURE_DENIED", False);
  dpyinfo->Xatom_wm_window_moved
    = XInternAtom (dpyinfo->display, "WM_MOVED", False);
  dpyinfo->Xatom_editres
    = XInternAtom (dpyinfo->display, "Editres", False);
  dpyinfo->Xatom_CLIPBOARD
    = XInternAtom (dpyinfo->display, "CLIPBOARD", False);
  dpyinfo->Xatom_TIMESTAMP
    = XInternAtom (dpyinfo->display, "TIMESTAMP", False);
  dpyinfo->Xatom_TEXT
    = XInternAtom (dpyinfo->display, "TEXT", False);
  dpyinfo->Xatom_DELETE
    = XInternAtom (dpyinfo->display, "DELETE", False);
  dpyinfo->Xatom_MULTIPLE
    = XInternAtom (dpyinfo->display, "MULTIPLE", False);
  dpyinfo->Xatom_INCR
    = XInternAtom (dpyinfo->display, "INCR", False);
  dpyinfo->Xatom_EMACS_TMP
    = XInternAtom (dpyinfo->display, "_EMACS_TMP_", False);
  dpyinfo->Xatom_TARGETS
    = XInternAtom (dpyinfo->display, "TARGETS", False);
  dpyinfo->Xatom_NULL
    = XInternAtom (dpyinfo->display, "NULL", False);
  dpyinfo->Xatom_ATOM_PAIR
    = XInternAtom (dpyinfo->display, "ATOM_PAIR", False);

  connection = ConnectionNumber (dpyinfo->display);
  dpyinfo->connection = connection;

#ifdef subprocesses
  /* This is only needed for distinguishing keyboard and process input.  */
  if (connection != 0)
    change_keyboard_wait_descriptor (connection);
#endif
  change_input_fd (connection);

#ifndef F_SETOWN_BUG
#ifdef F_SETOWN
  old_fcntl_owner = fcntl (connection, F_GETOWN, 0);
#ifdef F_SETOWN_SOCK_NEG
  /* stdin is a socket here */
  fcntl (connection, F_SETOWN, -getpid ());
#else /* ! defined (F_SETOWN_SOCK_NEG) */
  fcntl (connection, F_SETOWN, getpid ());
#endif /* ! defined (F_SETOWN_SOCK_NEG) */
#endif /* ! defined (F_SETOWN) */
#endif /* F_SETOWN_BUG */

#ifdef SIGIO

  /* Try to use interrupt input; if we can't, then start polling.  */
  Fset_input_mode (Qt, Qnil, Qt, Qnil);

  /* Note that there is no real way portable across R3/R4 to get the
     original error handler.  */
  XSetErrorHandler (x_error_quitter);
  XSetIOErrorHandler (x_io_error_quitter);

  /* Disable Window Change signals;  they are handled by X events. */
#ifdef SIGWINCH
  signal (SIGWINCH, SIG_DFL);
#endif /* ! defined (SIGWINCH) */

}

void
syms_of_xterm ()
{
  the_x_screen.font_list_cache = Qnil;
  the_x_screen.name = Qnil;
  staticpro (&the_x_screen.font_list_cache);
  staticpro (&the_x_screen.name);

  staticpro (&last_mouse_scroll_bar);
  last_mouse_scroll_bar = Qnil;
  staticpro (&mouse_face_window);
  mouse_face_window = Qnil;
}