xfns.c

早期freebsd实现

  Window tempwindow;
  register int temppixelwidth;
  register int temppixelheight;
  register int tempx;
  register int tempy;
  register int intbord;
  Pixmap temp_brdr, temp_back;

  CHECK_NUMBER (internalborderwidth, 0);

  check_xterm ();
  
  if (XINT (internalborderwidth) < 0) XSETINT (internalborderwidth, 0);
  intbord = XINT (internalborderwidth);
  temppixelwidth = screen_width * fontinfo->width + 2 * intbord;
  temppixelheight = screen_height * fontinfo->height + 2 * intbord;
  BLOCK_INPUT ();
  XQueryWindow (XXwindow, &WinInfo);
  tempx = WinInfo.x;
  tempy = WinInfo.y;
  if (grey_p (brdr_color))
    temp_brdr = XMakePixmap ((Bitmap) XStoreBitmap (16, 16, gray_bits),
			     BlackPixel, WhitePixel);
  else
    temp_brdr = XMakeTile (brdr);
  temp_back = XMakeTile (back);
  tempwindow = XCreateWindow (RootWindow,
			      tempx /* Absolute horizontal offset */,
			      tempy /* Absolute Vertical offset */,
			      temppixelwidth, temppixelheight,
			      XXborder,
			      temp_brdr, temp_back);
  if (tempwindow) 
    {
      XDestroyWindow (XXwindow);
      XXwindow = tempwindow;
      pixelwidth = temppixelwidth;
      pixelheight = temppixelheight;
      XXInternalBorder = intbord;
      XSelectInput (XXwindow, NoEvent);
      XSetResizeHint (XXwindow, 2 * XXInternalBorder, 2 * XXInternalBorder,
		      /* fontinfo->width * 1, fontinfo->height * 1, */
		      fontinfo->width, fontinfo->height);
      XStoreName (XXwindow, &iconidentity[0]);
      XDefineCursor (XXwindow, EmacsCursor);
      XFreePixmap (temp_brdr);
      XFreePixmap (temp_back);
      UNBLOCK_INPUT_RESIGNAL ();
      if (WindowMapped)
	{
	  XMapWindow (XXwindow);
	  XSelectInput (XXwindow, KeyPressed | ExposeWindow | ButtonPressed
#ifndef HPUX
			| ButtonReleased
#endif
			| ExposeRegion | ExposeCopy);
	  ++screen_garbaged;
	  XFlush ();
	}
      return Qt;
    }
  else
    {
      UNBLOCK_INPUT_RESIGNAL ();
      message ("Could not recreate window.");
      return Qnil;
    }
}

jmp_buf dispenv;
Display *OldDisplay;
FontInfo *OldFontInfo;
Window OldWindow;

XRestoreDisplay ()
{
  longjmp (dispenv, "Unable to access display (probably)");
}

DEFUN ("x-change-display", Fx_change_display, Sx_change_display, 1, 1,
  "sNew display name: ", 
  "This function takes one argument, the display where you wish to\n\
continue your editing session.  Your current window will be unmapped and\n\
the current display will be closed.  The new X display will be opened and\n\
the rubber-band outline of the new window will appear on the new X display.\n\
This function does not look at your .Xdefaults file, so you should use the\n\
function x-new-display instead.")
  (new_display)
     register Lisp_Object new_display;
{
  Cursor OldEmacsCursor;
  BLOCK_INPUT_DECLARE ()
  register int (*pipefunc) ();
  register char *newdisplayname = 0;
  int x, y, width, height;
  int temp_icon;
  int XRestoreDisplay ();
  Pixmap temp_brdr, temp_back;
  register char *XXerrorcode;

  CHECK_STRING (new_display, 1);
  check_xterm ();

/*  newdisplayname = xmalloc (XSTRING (new_display)->size + 1); */
/*  bcopy (XSTRING (new_display)->data, newdisplayname, */
/*	 XSTRING (new_display)->size + 1);  */
  /* Since this was freed at the end, why not just use the original? */
  newdisplayname = (char *) XSTRING (new_display)->data;
  BLOCK_INPUT ();
  XIOErrorHandler (XRestoreDisplay);
   if (XXerrorcode = (char *) setjmp (dispenv))
     {
 /*       free (&newdisplayname[0]); */
       if (fontinfo)
	 XCloseFont (fontinfo);
       if (XXwindow)
	 XDestroyWindow (XXwindow);
       if (XXdisplay)
	 XCloseDisplay (XXdisplay);
       XXdisplay = OldDisplay;
       fontinfo = OldFontInfo;
       XXwindow = OldWindow;
       EmacsCursor = OldEmacsCursor;
       XIOErrorHandler (handler);
       XSetDisplay (XXdisplay);
       UNBLOCK_INPUT_RESIGNAL ();
       error ("Display change problem: %s", XXerrorcode);
     }
   else
     {
       OldEmacsCursor = EmacsCursor;
       OldDisplay = XXdisplay;
       OldFontInfo = fontinfo;
       OldWindow = XXwindow;
       XXwindow = 0;
       fontinfo = 0;
       XXdisplay = 0;
     }
   XXdisplay = XOpenDisplay (newdisplayname);
   if (!XXdisplay)
     {
       longjmp (dispenv, "Probably nonexistant display");
     }
   XQueryWindow (RootWindow, &rootwindowinfo);
   fontinfo = XOpenFont (XXcurrentfont);
   if (!fontinfo)
     {
       longjmp (dispenv, "Bad font");
     }
   /* pixelwidth and pixelheight are correct*/
   XXwindow = XCreateWindow (RootWindow,
			     XXxoffset,
			     XXyoffset,
			     pixelwidth, pixelheight,
			     XXborder, BlackPixmap, WhitePixmap);
   if (!XXwindow)
     {
       longjmp (dispenv, "Could not create window");
     }
   fore = BlackPixel;
   back = WhitePixel;
   brdr = BlackPixel;
   mous = BlackPixel;
   curs = BlackPixel;

   fore_color = "black";
   back_color = "white";
   brdr_color = "black";
   mous_color = "black";
   curs_color = "black";

   XSelectInput (XXwindow, NoEvent);
   EmacsCursor = XCreateCursor (16, 16, MouseCursor, MouseMask,
				0, 0, mous, back, GXcopy);
  XDefineCursor (XXwindow, EmacsCursor);
  XSetResizeHint (XXwindow, 2 * XXInternalBorder, 2 * XXInternalBorder,
		  /* fontinfo->width * 1, fontinfo->height * 1, */
		  fontinfo->width, fontinfo->height);
   XStoreName (XXwindow, iconidentity);
/*  WindowMapped = 0;*/
  x_edges_specified = 0;
  bitblt = 0;
  CursorExists = 0;
  VisibleX = 0;
  VisibleY = 0;
  XSetDisplay (XXdisplay);
/*  XQueryWindow (RootWindow, &rootwindowinfo);*/
/*  if (WindowMapped)
    {*/
  XXIconWindow = XCreateWindow (RootWindow, 0, 0, sink_width, sink_height,
				2, WhitePixmap, BlackPixmap);
  XXIconMask = XStoreBitmap (sink_mask_width, sink_mask_height, sink_mask_bits);
  WindowMapped = 0;
  XPopUpWindow ();
/*  }*/
  WindowMapped = 1;
  XSetDisplay (OldDisplay);
  XCloseFont (OldFontInfo);
  XFreeCursor (OldEmacsCursor);
  XDestroyWindow (OldWindow);
  XSetDisplay (XXdisplay);
  XCloseDisplay (OldDisplay);

  x_init_1 (0);
  UNBLOCK_INPUT_RESIGNAL ();
/*  free (newdisplayname); */
/*  x_edges_specified = 0;*/
  ++screen_garbaged;
  Fredraw_display ();
  return Qt;
}

/*
   Grabs mouse, outlines a window, etc.
   if left button pressed, sizes a wd x hd window (in characters)
   if right button pressed, sizes wd x what will fit window (in characters)
   if middle button pressed, allows user to size window in font increments
   	(+ border * 2 for inner border);
   While sizing, dimensions of window are displayed in upper left of root.
   str is also displayed there.
   In all cases, x and y are the desired coordinates for the upper lefthand
   	corner, *width = width desired, *height = height desired
	(min for both is 1 font char).

	*/
/*
  This routine is a total crock.  It makes a window using XCreateTerm
  purely for return value, destroying the temporary window created in
  the process.  If XCreateTerm were broken into smaller, more easily
  digestible pieces, it would be useful.  As such, the constraints of
  time, emacs, and X conventions force me into this crock. --rlk
  */

window_fetch (font, x, y, width, height, geo, deflt, border, str)
     Font font;
     int *x, *y, *width, *height;
     char *geo, *deflt;
     int border;
     char *str;
{
  OpaqueFrame frame;
  Window tempwindow;
  WindowInfo WinInfo;
  register int temppixelwidth;
  register int temppixelheight;
  Pixmap temp_brdr, temp_back;

  temp_brdr = XMakeTile (brdr);
  temp_back = XMakeTile (back);
  frame.bdrwidth = border;
  if (grey_p (brdr_color))
    frame.border = XMakePixmap ((Bitmap) XStoreBitmap (16, 16, gray_bits),
				BlackPixel, WhitePixel);
  else
    frame.border = XMakeTile (brdr);
  frame.background = XMakeTile (back);
  tempwindow = XCreateTerm (str, "emacs", geo, deflt, &frame, 10, 5,
			    2 * XXInternalBorder, 2 * XXInternalBorder,
			    width, height, fontinfo, fontinfo->width,
			    fontinfo->height);
  if (tempwindow) 
    {
      XDestroyWindow (XXwindow);
      XXwindow = tempwindow;
      XSelectInput (XXwindow, NoEvent);
      XSetResizeHint (XXwindow, 2 * XXInternalBorder, 2 * XXInternalBorder,
		      /* fontinfo->width * 1, fontinfo->height * 1, */
		      fontinfo->width, fontinfo->height);
      XStoreName (XXwindow, &iconidentity[0]);
      XDefineCursor (XXwindow, EmacsCursor);
      XQueryWindow (XXwindow, &WinInfo);
      *x = WinInfo.x;
      *y = WinInfo.y;
      XFreePixmap (temp_brdr);
      XFreePixmap (temp_back);
      RESIGNAL_INPUT ();
      if (WindowMapped)
	{
	  XMapWindow (XXwindow);
	  XSelectInput (XXwindow, KeyPressed | ExposeWindow | ButtonPressed
#ifndef HPUX
			| ButtonReleased
#endif
			| ExposeRegion | ExposeCopy);
	  ++screen_garbaged;
	  XFlush ();
	}
      return Qt;
    }
  else
    {
      RESIGNAL_INPUT ();
      message ("Could not recreate window.");
      return Qnil;
    }
}

DEFUN ("x-rebind-key", Fx_rebind_key, Sx_rebind_key, 3, 3, 0,
  "Rebind KEYCODE, with shift bits SHIFT-MASK, to new string NEWSTRING.\n\
KEYCODE and SHIFT-MASK should be numbers representing the X keyboard code\n\
and shift mask respectively.  NEWSTRING is an arbitrary string of keystrokes.\n\
If SHIFT-MASK is nil, then KEYCODE's key will be bound to NEWSTRING for\n\
all shift combinations.\n\
Shift Lock  1	   Shift    2\n\
Meta	    4	   Control  8\n\
\n\
For values of KEYCODE, see /usr/lib/Xkeymap.txt (remember that the codes\n\
in that file are in octal!)\n\
\n\
NOTE: due to an X bug, this function will not take effect unless one has\n\
a ~/.Xkeymap file.  (See the documentation for the \"keycomp\" program.)\n\
This problem will be fixed in X version 11.")

  (keycode, shift_mask, newstring)
     register Lisp_Object keycode;
     register Lisp_Object shift_mask;
     register Lisp_Object newstring;
{
  char *rawstring;
  int rawkey, rawshift;
  int i;
  int strsize;

  CHECK_NUMBER (keycode, 1);
  if (!NULL (shift_mask))
    CHECK_NUMBER (shift_mask, 2);
  CHECK_STRING (newstring, 3);
  strsize = XSTRING (newstring) ->size;
  rawstring = (char *) xmalloc (strsize);
  bcopy (XSTRING (newstring)->data, rawstring, strsize);
  rawkey = ((unsigned) (XINT (keycode))) & 255;
  if (NULL (shift_mask))
    for (i = 0; i <= 15; i++)
      XRebindCode (rawkey, i<<11, rawstring, strsize);
  else
    {
      rawshift = (((unsigned) (XINT (shift_mask))) & 15) << 11;
      XRebindCode (rawkey, rawshift, rawstring, strsize);
    }
  return Qnil;
}
  
DEFUN ("x-rebind-keys", Fx_rebind_keys, Sx_rebind_keys, 2, 2, 0,
  "Rebind KEYCODE to list of strings STRINGS.\n\
STRINGS should be a list of 16 elements, one for each all shift combination.\n\
nil as element means don't change.\n\
See the documentation of x-rebind-key for more information.")
  (keycode, strings)
     register Lisp_Object keycode;
     register Lisp_Object strings;
{
  register Lisp_Object item;
  register char *rawstring;
  int rawkey, strsize;
  register unsigned i;

  CHECK_NUMBER (keycode, 1);
  CHECK_CONS (strings, 2);
  rawkey = ((unsigned) (XINT (keycode))) & 255;
  for (i = 0; i <= 15; strings = Fcdr (strings), i++)
    {
      item = Fcar (strings);
      if (!NULL (item))
	{
	  CHECK_STRING (item, 2);
	  strsize = XSTRING (item)->size;
	  rawstring = (char *) xmalloc (strsize);
	  bcopy (XSTRING (item)->data, rawstring, strsize);
	  XRebindCode (rawkey, i << 11, rawstring, strsize);
	}
    }
  return Qnil;
}

XExitWithCoreDump (Disp, Event)
     Display *Disp;
     XErrorEvent *Event;
{
  XCleanUp ();
  abort ();
}

DEFUN ("x-debug", Fx_debug, Sx_debug, 1, 1, 0,
  "ARG non-nil means that X errors should generate a coredump.")
  (arg)
     register Lisp_Object arg;
{
  if (!NULL (arg))
    handler = XExitWithCoreDump;
  else
    {
      extern int XExitGracefully ();
      handler = XExitGracefully;
    }
  XErrorHandler (handler);
  XIOErrorHandler (handler);
  return (Qnil);
}

XRedrawDisplay ()
{
  Fredraw_display ();
}

XCleanUp ()
{
  Fdo_auto_save (Qt);
#ifdef subprocesses
  kill_buffer_processes (Qnil);
#endif /* subprocesses */
}


syms_of_xfns ()
{
  x_edges_specified = 0;

  DEFVAR_LISP ("x-mouse-item", &Vx_mouse_item,
     "Encoded representation of last mouse click, corresponding to\n\
numerical entries in x-mouse-map.");
  Vx_mouse_item = Qnil;
  DEFVAR_LISP ("x-mouse-pos", &Vx_mouse_pos,
     "Current x-y position of mouse by row, column as specified by font.");
  Vx_mouse_pos = Qnil;
  DEFVAR_LISP ("x-mouse-abs-pos", &Vx_mouse_abs_pos,
     "Current x-y position of mouse by row, column in pixels, wrt root window.");
  Vx_mouse_abs_pos = Qnil;

  defsubr (&Sx_pop_up_window);
  defsubr (&Sx_set_bell);
  defsubr (&Sx_flip_color);
  defsubr (&Sx_set_icon);
  defsubr (&Sx_set_font);
  defsubr (&Sx_set_window_edges);
  defsubr (&Scoordinates_in_window_p);
  defsubr (&Sx_mouse_events);
  defsubr (&Sx_proc_mouse_event);
  defsubr (&Sx_get_mouse_event);
  defsubr (&Sx_set_keyboard_enable);
  defsubr (&Sx_set_mouse_inform_flag);
  defsubr (&Sx_store_cut_buffer);
  defsubr (&Sx_get_cut_buffer);
  defsubr (&Sx_rubber_band);
  defsubr (&Sx_create_x_window);
  defsubr (&Sx_set_border_width);
  defsubr (&Sx_set_internal_border_width);
  defsubr (&Sx_change_display);
  defsubr (&Sx_set_foreground_color);
  defsubr (&Sx_set_background_color);
  defsubr (&Sx_set_border_color);
  defsubr (&Sx_set_cursor_color);
  defsubr (&Sx_set_mouse_color);
  defsubr (&Sx_get_foreground_color);
  defsubr (&Sx_get_background_color);
  defsubr (&Sx_get_border_color);
  defsubr (&Sx_get_cursor_color);
  defsubr (&Sx_get_mouse_color);
  defsubr (&Sx_color_p);
  defsubr (&Sx_get_default);
  defsubr (&Sx_rebind_key);
  defsubr (&Sx_rebind_keys);
  defsubr (&Sx_debug);
}

#endif /* HAVE_X_WINDOWS */