Return to xterm.c CVS log

Up to [Apple XNU] / GNUtools / emacs / src

Annotation of GNUtools/emacs/src/xterm.c, revision 1.1

1.1     ! root        1: /* X Communication module for terminals which understand the X protocol.
        !             2:    Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
        !             3: 
        !             4: This file is part of GNU Emacs.
        !             5: 
        !             6: GNU Emacs is free software; you can redistribute it and/or modify
        !             7: it under the terms of the GNU General Public License as published by
        !             8: the Free Software Foundation; either version 1, or (at your option)
        !             9: any later version.
        !            10: 
        !            11: GNU Emacs is distributed in the hope that it will be useful,
        !            12: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14: GNU General Public License for more details.
        !            15: 
        !            16: You should have received a copy of the GNU General Public License
        !            17: along with GNU Emacs; see the file COPYING.  If not, write to
        !            18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: /* Written by Yakim Martillo, mods and things by Robert Krawitz  */
        !            21: 
        !            22: /*
        !            23:  *     $Source: /u2/third_party/gnuemacs.chow/src/RCS/xterm.c,v $
        !            24:  *     $Author: rlk $
        !            25:  *     $Locker:  $
        !            26:  *     $Header: xterm.c,v 1.28 86/08/27 13:30:57 rlk Exp $
        !            27:  */
        !            28: 
        !            29: #ifndef lint
        !            30: static char *rcsid_TrmXTERM_c = "$Header: xterm.c,v 1.28 86/08/27 13:30:57 rlk Exp $";
        !            31: #endif lint
        !            32: 
        !            33: /* On 4.3 this loses if it comes after xterm.h.  */
        !            34: #include <signal.h>
        !            35: #include "config.h"
        !            36: 
        !            37: #ifdef HAVE_X_WINDOWS
        !            38: 
        !            39: #include "lisp.h"
        !            40: #undef NULL
        !            41: 
        !            42: /* This may include sys/types.h, and that somehow loses
        !            43:    if this is not done before the other system files.  */
        !            44: #include "xterm.h"
        !            45: 
        !            46: /* Load sys/types.h if not already loaded.
        !            47:    In some systems loading it twice is suicidal.  */
        !            48: #ifndef makedev
        !            49: #include <sys/types.h>
        !            50: #endif
        !            51: 
        !            52: #if !defined(USG) || defined(IBMRTAIX)
        !            53: #include <sys/time.h>
        !            54: #else
        !            55: #include <time.h>
        !            56: #endif /* USG and not IBMRTAIX */
        !            57: 
        !            58: #include <sys/ioctl.h>
        !            59: #include <fcntl.h>
        !            60: #include <stdio.h>
        !            61: #include <ctype.h>
        !            62: #include <errno.h>
        !            63: #ifdef BSD
        !            64: #include <strings.h>
        !            65: #endif
        !            66: #include <sys/stat.h>
        !            67: 
        !            68: #include "dispextern.h"
        !            69: #include "termhooks.h"
        !            70: #include "termopts.h"
        !            71: #include "termchar.h"
        !            72: #include "sink.h"
        !            73: #include "sinkmask.h"
        !            74: #include <X/Xkeyboard.h>
        !            75: /*#include <X/Xproto.h>        */
        !            76: 
        !            77: /* Allow m- file to inhibit use of FIONREAD.  */
        !            78: #ifdef BROKEN_FIONREAD
        !            79: #undef FIONREAD
        !            80: #endif
        !            81: 
        !            82: /* We are unable to use interrupts if FIONREAD is not available,
        !            83:    so flush SIGIO so we won't try. */
        !            84: #ifndef FIONREAD
        !            85: #ifdef SIGIO
        !            86: #undef SIGIO
        !            87: #endif
        !            88: #endif
        !            89: 
        !            90: /* Allow config to specify default font.  */
        !            91: #ifndef X_DEFAULT_FONT
        !            92: #define X_DEFAULT_FONT "vtsingle"
        !            93: #endif
        !            94: 
        !            95: #define min(a,b) ((a)<(b) ? (a) : (b))
        !            96: #define max(a,b) ((a)>(b) ? (a) : (b))
        !            97: #define sigunblockx(sig) sigblock (0)
        !            98: #define sigblockx(sig) sigblock (1 << ((sig) - 1))
        !            99: XREPBUFFER Xxrepbuffer;
        !           100: int pixelwidth;
        !           101: int pixelheight;
        !           102: int PendingExposure;
        !           103: int PendingIconExposure;
        !           104: #define MAXICID 80
        !           105: char iconidentity[MAXICID];
        !           106: #define ICONTAG "emacs@"
        !           107: #define METABIT 0x80
        !           108: Window XXIconWindow;
        !           109: Bitmap XXIconMask;
        !           110: 
        !           111: char *XXcurrentfont;
        !           112: char *default_window;
        !           113: int informflag;
        !           114: extern int initialized;
        !           115: 
        !           116: extern char *alternate_display;
        !           117: 
        !           118: int XXdebug;
        !           119: int XXpid;
        !           120: extern int screen_garbaged;
        !           121: int XXxoffset, XXyoffset;
        !           122: int IconWindow;
        !           123: 
        !           124: int WindowMapped;
        !           125: int CurHL;
        !           126: 
        !           127: static int flexlines;          /* last line affect by dellines or */
        !           128:                                /* inslines functions */
        !           129: extern int errno;
        !           130: int VisibleX, VisibleY;        /* genuine location of cursor on screen */
        !           131:                                /* if it is there */
        !           132: static int SavedX, SavedY;     /* Where the cursor was before update */
        !           133:                                /* started */
        !           134: 
        !           135: int bitblt;            /* Used to track bit blt events */
        !           136: int CursorExists;      /* during updates cursor is turned off */
        !           137: static int InUpdate;           /* many of functions here may be invoked */
        !           138:                                /* even if no update in progress, when */
        !           139:                                /* no update is in progress the action */
        !           140:                                /* can be slightly different */
        !           141: 
        !           142: short MouseCursor[] = {
        !           143:   0x0000, 0x0008, 0x0018, 0x0038,
        !           144:   0x0078, 0x00f8, 0x01f8, 0x03f8,
        !           145:   0x07f8, 0x00f8, 0x00d8, 0x0188,
        !           146:   0x0180, 0x0300, 0x0300, 0x0000};
        !           147: 
        !           148: short MouseMask[] = {
        !           149:   0x000c, 0x001c, 0x003c, 0x007c,
        !           150:   0x00fc, 0x01fc, 0x03fc, 0x07fc,
        !           151:   0x0ffc, 0x0ffc, 0x01fc, 0x03dc,
        !           152:   0x03cc, 0x0780, 0x0780, 0x0300};
        !           153: 
        !           154: Display *XXdisplay;
        !           155: FontInfo *fontinfo;
        !           156: Window XXwindow;
        !           157: Cursor EmacsCursor;
        !           158: 
        !           159: char *fore_color;      /* Variables to store colors */
        !           160: char *back_color;
        !           161: char *brdr_color;
        !           162: char *curs_color;
        !           163: char *mous_color;
        !           164: 
        !           165: int fore;
        !           166: int back;
        !           167: int brdr;
        !           168: int curs;
        !           169: int mous;
        !           170: 
        !           171: static WindowInfo windowinfo;
        !           172: WindowInfo rootwindowinfo;
        !           173: 
        !           174: 
        !           175: 
        !           176: static XKeyPressedEvent XXEvent; /* as X messages are read in they are */
        !           177:                                 /* stored here */
        !           178: static XREPBUFFER XXqueue;/* Used for storing up ExposeRegion */
        !           179:                                /* replies, so that the SIGIO inter- */
        !           180:                                /* rupt serving routines do almost */
        !           181:                                /* no writes to the X socket */
        !           182: /*int CurHL;                   /* Current Highlighting actually being */
        !           183:                                /* being used for bold font right now*/
        !           184: 
        !           185: int XXborder;
        !           186: int XXInternalBorder;
        !           187: 
        !           188: int (*handler)();
        !           189: 
        !           190: extern Display *XOpenDisplay ();
        !           191: extern Window XCreateWindow ();
        !           192: extern Cursor XDefineCursor ();
        !           193: extern Cursor XCreateCursor ();
        !           194: extern FontInfo *XOpenFont ();
        !           195: 
        !           196: static int flashback ();
        !           197: 
        !           198: 
        !           199: /* HLmode -- Changes the GX function for output strings.  Could be used to
        !           200:  * change font.  Check an XText library function call. 
        !           201:  */
        !           202: 
        !           203: static
        !           204: HLmode (new)
        !           205:      int new;
        !           206: {
        !           207:   CurHL =  new;
        !           208: }
        !           209: 
        !           210: 
        !           211: /* External interface to control of standout mode.
        !           212:    Call this when about to modify line at position VPOS
        !           213:    and not change whether it is highlighted.  */
        !           214: 
        !           215: XTreassert_line_highlight (highlight, vpos)
        !           216:      int highlight, vpos;
        !           217: {
        !           218:   HLmode (highlight);
        !           219: }
        !           220: 
        !           221: /* Call this when about to modify line at position VPOS
        !           222:    and change whether it is highlighted.  */
        !           223: 
        !           224: static
        !           225: XTchange_line_highlight (new_highlight, vpos, first_unused_hpos)
        !           226:      int new_highlight, vpos, first_unused_hpos;
        !           227: {
        !           228:   HLmode (new_highlight);
        !           229:   XTmove_cursor (vpos, 0);
        !           230:   x_clear_end_of_line (0);
        !           231: }
        !           232: 
        !           233: 
        !           234: /* Used for starting or restarting (after suspension) the X window.  Puts the
        !           235:  * cursor in a known place, update does not begin with this routine but only
        !           236:  * with a call to redisplay.  The mouse cursor is warped into the window and
        !           237:  * then the cursor is turned on.
        !           238:  */
        !           239: 
        !           240: 
        !           241: 
        !           242: static
        !           243: XTset_terminal_modes ()
        !           244: {
        !           245:   int stuffpending;
        !           246: #ifdef XDEBUG
        !           247:   fprintf (stderr, "XTset_terminal_modes\n");
        !           248: #endif
        !           249:   InUpdate = 0;
        !           250:   stuffpending = 0;
        !           251:   if (!initialized)
        !           252:     {
        !           253:       CursorExists = 0;
        !           254:       VisibleX = 0;
        !           255:       VisibleY = 0;
        !           256:     }
        !           257:   XTclear_screen ();
        !           258: #ifdef FIONREAD
        !           259:   ioctl (0, FIONREAD, &stuffpending);
        !           260:   if (stuffpending)
        !           261:     SIGNAL_INPUT ();
        !           262: #endif
        !           263: }
        !           264: 
        !           265: /* XTmove_cursor moves the cursor to the correct location and checks whether an update
        !           266:  * is in progress in order to toggle it on.
        !           267:  */
        !           268: 
        !           269: static
        !           270: XTmove_cursor (row, col)
        !           271:      register int row, col;
        !           272: {
        !           273:   BLOCK_INPUT_DECLARE ()
        !           274: 
        !           275:   BLOCK_INPUT ();
        !           276: #ifdef XDEBUG
        !           277:   fprintf (stderr, "XTmove_cursor\n");
        !           278: #endif
        !           279:   cursor_hpos = col;
        !           280:   cursor_vpos = row;
        !           281:   if (InUpdate)
        !           282:     {
        !           283:       if (CursorExists)
        !           284:        {
        !           285:          CursorToggle ();
        !           286:        }
        !           287:       UNBLOCK_INPUT ();
        !           288:       return;          /* Generally, XTmove_cursor will be invoked */
        !           289:       /* when InUpdate with !CursorExists */
        !           290:       /* so that wasteful XFlush is not called */
        !           291:     }
        !           292:   if ((row == VisibleY) && (col == VisibleX))
        !           293:     {
        !           294:       if (!CursorExists)
        !           295:        {
        !           296:          CursorToggle ();
        !           297:        }
        !           298:       XFlush ();
        !           299:       UNBLOCK_INPUT ();
        !           300:       return;
        !           301:     }
        !           302:   if (CursorExists) CursorToggle ();
        !           303:   VisibleX = col;
        !           304:   VisibleY = row;
        !           305:   if (!CursorExists) CursorToggle ();
        !           306:   XFlush ();
        !           307:   UNBLOCK_INPUT ();
        !           308: }
        !           309: 
        !           310: /* Used to get the terminal back to a known state after resets.  Usually
        !           311:  * used when restarting suspended or waiting emacs
        !           312:  */
        !           313: 
        !           314: static
        !           315: cleanup ()
        !           316: {
        !           317:   inverse_video = 0;
        !           318:   HLmode (0);
        !           319: }
        !           320: 
        !           321: /* Erase current line from column cursor_hpos to column END.
        !           322:    Leave cursor at END.  */
        !           323: 
        !           324: static
        !           325: XTclear_end_of_line (end)
        !           326:      register int end;
        !           327: {
        !           328:   register int numcols;
        !           329: 
        !           330: #ifdef XDEBUG
        !           331:   fprintf (stderr, "XTclear_end_of_line\n");
        !           332: 
        !           333: #endif
        !           334:   if (cursor_vpos < 0 || cursor_vpos >= screen_height)
        !           335:     {
        !           336:       return;
        !           337:     }
        !           338: 
        !           339:   if (end >= screen_width)
        !           340:     end = screen_width;
        !           341:   if (end <= cursor_hpos)
        !           342:     return;
        !           343: 
        !           344:   numcols = end - cursor_hpos;
        !           345:   {
        !           346:     BLOCK_INPUT_DECLARE ()
        !           347: 
        !           348:     BLOCK_INPUT ();
        !           349:     if (cursor_vpos == VisibleY && VisibleX >= cursor_hpos && VisibleX < end)
        !           350:       {
        !           351:        if (CursorExists) CursorToggle ();
        !           352:       }
        !           353:     XPixSet (XXwindow,
        !           354:             cursor_hpos * fontinfo->width + XXInternalBorder,
        !           355:             cursor_vpos * fontinfo->height+XXInternalBorder,
        !           356:             fontinfo->width * numcols,
        !           357:             fontinfo->height,
        !           358:             back);
        !           359:     XTmove_cursor (cursor_vpos, end);
        !           360:     UNBLOCK_INPUT ();
        !           361:   }
        !           362: }
        !           363: 
        !           364: /* Erase current line from column START to right margin.
        !           365:    Leave cursor at START.  */
        !           366: 
        !           367: static
        !           368: x_clear_end_of_line (start)
        !           369:      register int start;
        !           370: {
        !           371:   register int numcols;
        !           372: 
        !           373: #ifdef XDEBUG
        !           374:   fprintf (stderr, "x_clear_end_of_line\n");
        !           375: 
        !           376: #endif
        !           377:   if (cursor_vpos < 0 || cursor_vpos >= screen_height)
        !           378:     {
        !           379:       return;
        !           380:     }
        !           381: 
        !           382:   if (start < 0)
        !           383:     start = 0;
        !           384:   if (start >= screen_width)
        !           385:     return;
        !           386: 
        !           387:   numcols = screen_width - start;
        !           388:   {
        !           389:     BLOCK_INPUT_DECLARE ()
        !           390: 
        !           391:     BLOCK_INPUT ();
        !           392:     if (cursor_vpos == VisibleY && VisibleX >= start)
        !           393:       {
        !           394:        if (CursorExists) CursorToggle ();
        !           395:       }
        !           396:     XPixSet (XXwindow,
        !           397:             start * fontinfo->width + XXInternalBorder,
        !           398:             cursor_vpos * fontinfo->height+XXInternalBorder,
        !           399:             fontinfo->width * numcols,
        !           400:             fontinfo->height,
        !           401:             back);
        !           402:     XTmove_cursor (cursor_vpos, start);
        !           403:     UNBLOCK_INPUT ();
        !           404:   }
        !           405: }
        !           406: 
        !           407: static
        !           408: XTreset_terminal_modes ()
        !           409: {
        !           410: #ifdef XDEBUG
        !           411:   fprintf (stderr, "XTreset_terminal_modes\n");
        !           412: #endif
        !           413:   XTclear_screen ();
        !           414: }
        !           415: 
        !           416: static
        !           417: XTclear_screen ()
        !           418: {
        !           419: #ifdef XDEBUG
        !           420:   fprintf (stderr, "XTclear_screen\n");
        !           421: #endif
        !           422:   HLmode (0);
        !           423:   CursorExists = 0;
        !           424: 
        !           425:   cursor_hpos = 0;
        !           426:   cursor_vpos = 0;
        !           427:   SavedX = 0;
        !           428:   SavedY = 0;
        !           429:   VisibleX = 0;
        !           430:   VisibleY = 0;
        !           431:   {
        !           432:     BLOCK_INPUT_DECLARE ()
        !           433: 
        !           434:     BLOCK_INPUT ();
        !           435:     XClear (XXwindow);
        !           436:     CursorToggle ();
        !           437:     if (!InUpdate)
        !           438:       XFlush ();
        !           439:     UNBLOCK_INPUT ();
        !           440:   }
        !           441: }
        !           442: 
        !           443: /* used by dumprectangle which is usually invoked upon ExposeRegion
        !           444:  * events which come from bit blt's or moving an obscuring opaque window
        !           445:  */
        !           446: 
        !           447: static
        !           448: dumpchars (current_screen, numcols, tempX, tempY, tempHL)
        !           449:      register struct matrix *current_screen;
        !           450:      register int numcols;
        !           451:      register int tempX, tempY, tempHL;
        !           452: {
        !           453:   if (numcols <= 0) return;
        !           454:   if (((numcols - 1) + tempX) > screen_width)
        !           455:     {
        !           456:       numcols = (screen_width - tempX) + 1;
        !           457:     }
        !           458:   if ((tempX < 0) || (tempX >= screen_width) ||
        !           459:       (tempY < 0) || (tempY >= screen_height))
        !           460:     {
        !           461:       return;
        !           462:     }
        !           463:   XText (XXwindow,
        !           464:         (tempX * fontinfo->width+XXInternalBorder),
        !           465:         (tempY * fontinfo->height+XXInternalBorder),
        !           466:         &current_screen->contents[tempY][tempX],
        !           467:         numcols,
        !           468:         fontinfo->id,
        !           469:         (tempHL ? back : fore),
        !           470:         (tempHL ? fore : back));
        !           471: }
        !           472: 
        !           473: /* When a line has been changed this function is called.  X is so fast
        !           474:  * that the actual sequence is ignore.  Rather, the new version of the
        !           475:  * line is simply output if this function is invoked while in UpDate.
        !           476:  * Sometimes writechars can be invoked when not in update if text is to
        !           477:  * be output at the end of the line.  In this case the whole line is not
        !           478:  * output.  Simply the new text at the current cursor position given
        !           479:  * by VisibleX,Y.  The cursor is moved to the end of the new text.
        !           480:  */
        !           481: static
        !           482: writechars (start, end)
        !           483:      register char *start, *end;
        !           484: {
        !           485:   register int temp_length;
        !           486:   BLOCK_INPUT_DECLARE ()
        !           487: 
        !           488:   BLOCK_INPUT ();
        !           489: 
        !           490:   if ((cursor_vpos < 0) || (cursor_vpos >= screen_height))
        !           491:     {
        !           492:       UNBLOCK_INPUT ();
        !           493:       return;
        !           494:     }
        !           495:   if (CursorExists)
        !           496:     {
        !           497:       CursorToggle ();
        !           498:     }
        !           499:   if (InUpdate)
        !           500:     {
        !           501:       if (end != start - 1)
        !           502:        {
        !           503:          XText (XXwindow,
        !           504:                 (cursor_hpos * fontinfo->width+XXInternalBorder),
        !           505:                 (cursor_vpos * fontinfo->height+XXInternalBorder),
        !           506:                 start,
        !           507:                 end + 1 - start,
        !           508:                 fontinfo->id,
        !           509:                 (CurHL ? back : fore),
        !           510:                 (CurHL ? fore : back));
        !           511:          XTmove_cursor (cursor_vpos, cursor_hpos + end - start + 1);
        !           512:        }
        !           513:     }
        !           514:   else
        !           515:     {
        !           516:       if ((VisibleX < 0) || (VisibleX >= screen_width))
        !           517:        {
        !           518:          UNBLOCK_INPUT ();
        !           519:          return;
        !           520:        }
        !           521:       if ((VisibleY < 0) || (VisibleY >= screen_height))
        !           522:        {
        !           523:          UNBLOCK_INPUT ();
        !           524:          return;
        !           525:        }
        !           526:       if (((end - start) + VisibleX) >= screen_width)
        !           527:        {
        !           528:          end = start + (screen_width - (VisibleX + 1));
        !           529:        }
        !           530:       if (end >= start)
        !           531:        {
        !           532:           XText (XXwindow,
        !           533:                 (VisibleX * fontinfo->width+XXInternalBorder),
        !           534:                 (VisibleY * fontinfo->height+XXInternalBorder),
        !           535:                 start,
        !           536:                 ((end - start) + 1),
        !           537:                 fontinfo->id,
        !           538:                 (CurHL ? back : fore),
        !           539:                 (CurHL ? fore : back));
        !           540:          VisibleX = VisibleX + (end - start) + 1;
        !           541:        }
        !           542:       if (!CursorExists) CursorToggle ();
        !           543:     }
        !           544:   UNBLOCK_INPUT ();
        !           545: }
        !           546: 
        !           547: 
        !           548: static
        !           549: XToutput_chars (start, len)
        !           550:      register char *start;
        !           551:      register int len;
        !           552: {
        !           553: #ifdef XDEBUG
        !           554:   fprintf (stderr, "XToutput_chars\n");
        !           555: #endif
        !           556:   writechars (start, start + len - 1);
        !           557: }
        !           558: 
        !           559: /* The following routine is for the deaf or for the pervert who prefers
        !           560:  * that his terminal flash at him rather than beep at him.
        !           561:  */
        !           562: 
        !           563: static int flashedback;
        !           564: 
        !           565: static
        !           566: XTflash ()
        !           567: {
        !           568: #ifdef ITIMER_REAL
        !           569:   struct itimerval itimer;
        !           570: 
        !           571: #ifdef XDEBUG
        !           572:   fprintf (stderr, "XTflash\n");
        !           573: #endif
        !           574: 
        !           575:   stop_polling ();
        !           576:   signal (SIGALRM, flashback);
        !           577:   getitimer (ITIMER_REAL, &itimer);
        !           578:   itimer.it_value.tv_usec += 250000;
        !           579:   itimer.it_interval.tv_sec = 0;
        !           580:   itimer.it_interval.tv_usec = 0;
        !           581:   flashedback = 0;
        !           582:   setitimer (ITIMER_REAL, &itimer, 0);
        !           583:   {
        !           584:     BLOCK_INPUT_DECLARE ()
        !           585: 
        !           586:     BLOCK_INPUT ();
        !           587:     XPixFill (XXwindow, 0, 0, screen_width*fontinfo->width+2*XXInternalBorder,
        !           588:              screen_height * fontinfo->height+2*XXInternalBorder, WhitePixel,
        !           589:              ClipModeClipped, GXinvert, AllPlanes);
        !           590:     XFlush ();
        !           591:     UNBLOCK_INPUT ();
        !           592:   }
        !           593:   while (!flashedback) pause ();
        !           594: #endif /* have ITIMER_REAL */
        !           595: }
        !           596: 
        !           597: static
        !           598: flashback ()
        !           599: {
        !           600: #ifdef ITIMER_REAL
        !           601: #ifdef SIGIO
        !           602:   int mask = sigblock (sigmask (SIGIO) | sigmask (SIGALRM));
        !           603: #else
        !           604:   int mask = sigblock (sigmask (SIGALRM));
        !           605: #endif
        !           606:   XPixFill (XXwindow, 0, 0, screen_width * fontinfo->width+2*XXInternalBorder,
        !           607:            screen_height * fontinfo->height+2*XXInternalBorder, WhitePixel,
        !           608:            ClipModeClipped, GXinvert, AllPlanes);
        !           609:   XFlush ();
        !           610:   flashedback = 1;
        !           611:   sigsetmask (mask);
        !           612:   start_polling ();
        !           613: #endif /* have ITIMER_REAL */
        !           614: }
        !           615: 
        !           616: /* A kludge to get a bell */
        !           617: 
        !           618: static
        !           619: XTfeep ()
        !           620: {
        !           621:   BLOCK_INPUT_DECLARE ()
        !           622: 
        !           623:   BLOCK_INPUT ();
        !           624: #ifdef XDEBUG
        !           625:   fprintf (stderr, "XTfeep\n");
        !           626: #endif
        !           627:   XFeep (0);
        !           628:   UNBLOCK_INPUT ();
        !           629: }
        !           630: 
        !           631: /* Artificially creating a cursor is hard, the actual position on the
        !           632:  * screen (either where it is or last was) is tracked with VisibleX,Y.
        !           633:  * Gnu Emacs code tends to assume a cursor exists in hardward at cursor_hpos,Y
        !           634:  * and that output text will appear there.  During updates, the cursor is
        !           635:  * supposed to be blinked out and will only reappear after the update
        !           636:  * finishes.
        !           637:  */
        !           638: 
        !           639: CursorToggle ()
        !           640: {
        !           641:   if (!WindowMapped)
        !           642:     {
        !           643:       CursorExists = 0;
        !           644:       return 0;
        !           645:     }
        !           646:   if ((VisibleX < 0) || (VisibleX >= screen_width) ||
        !           647:       (VisibleY < 0) || (VisibleY >= screen_height))
        !           648:     {                  /* Current Cursor position trash */
        !           649:       /* Not much can be done */
        !           650:       XFlush ();
        !           651:       CursorExists = 0;
        !           652:       return 0;
        !           653:       /* Currently the return values are not */
        !           654:       /* used, but I could anticipate using */
        !           655:       /* them in the future. */
        !           656:     }
        !           657: 
        !           658:   if (current_screen->enable[VisibleY] &&
        !           659:       (VisibleX < current_screen->used[VisibleY]))
        !           660:     {
        !           661:       if (CursorExists)
        !           662:        {
        !           663:          XText (XXwindow,
        !           664:                 VisibleX * fontinfo->width+XXInternalBorder,
        !           665:                 VisibleY * fontinfo->height+XXInternalBorder,
        !           666:                 &current_screen->contents[VisibleY][VisibleX], 1,
        !           667:                 fontinfo->id,
        !           668:                 fore, back);
        !           669:        }
        !           670:       else
        !           671:        {
        !           672:          XText (XXwindow,
        !           673:                 VisibleX * fontinfo->width+XXInternalBorder,
        !           674:                 VisibleY * fontinfo->height+XXInternalBorder,
        !           675:                 &current_screen->contents[VisibleY][VisibleX], 1,
        !           676:                 fontinfo->id,
        !           677:                 back, curs);
        !           678:        }
        !           679:     }
        !           680:   else if (CursorExists)
        !           681:     {
        !           682:       XPixSet (XXwindow,
        !           683:               VisibleX * fontinfo->width+XXInternalBorder,
        !           684:               VisibleY * fontinfo->height+XXInternalBorder,
        !           685:               fontinfo->width, fontinfo->height, back);
        !           686:     }
        !           687:   else
        !           688:     {
        !           689:       XPixSet (XXwindow,
        !           690:               VisibleX * fontinfo->width+XXInternalBorder,
        !           691:               VisibleY * fontinfo->height+XXInternalBorder,
        !           692:               fontinfo->width, fontinfo->height, curs);
        !           693:     }
        !           694:   CursorExists = !CursorExists;
        !           695:   /* Cursor has either been blinked in */
        !           696:   /* or out */
        !           697:   if (!InUpdate)
        !           698:     {
        !           699:       XFlush ();
        !           700:     }
        !           701:   return 1;
        !           702: }
        !           703: 
        !           704: /* This routine is used by routines which are called to paint regions */
        !           705: /* designated by ExposeRegion events.  If the cursor may be in the exposed */
        !           706: /* region, this routine makes sure it is gone so that dumprectangle can */
        !           707: /* toggle it back into existance if dumprectangle is invoked when not in */
        !           708: /* the midst of a screen update. */
        !           709: static
        !           710: ClearCursor ()
        !           711: {
        !           712:   BLOCK_INPUT_DECLARE ()
        !           713: 
        !           714:   BLOCK_INPUT ();
        !           715:   if (!WindowMapped)
        !           716:     {
        !           717:       CursorExists = 0;
        !           718:       UNBLOCK_INPUT ();
        !           719:       return;
        !           720:     }
        !           721:   if ((VisibleX < 0) || (VisibleX >= screen_width)
        !           722:       || (VisibleY < 0) || (VisibleY >= screen_height))
        !           723:     {                  /* Current Cursor position trash */
        !           724:       /* Not much can be done */
        !           725:       CursorExists = 0;
        !           726:       UNBLOCK_INPUT ();
        !           727:       return;
        !           728:     }
        !           729:   XPixSet (XXwindow,
        !           730:          VisibleX * fontinfo->width+XXInternalBorder,
        !           731:          VisibleY * fontinfo->height+XXInternalBorder,
        !           732:          fontinfo->width, fontinfo->height,
        !           733:          back);
        !           734:   CursorExists = 0;
        !           735:   UNBLOCK_INPUT ();
        !           736: }
        !           737: 
        !           738: static
        !           739: XTupdate_begin ()
        !           740: {
        !           741:   BLOCK_INPUT_DECLARE ()
        !           742: 
        !           743:   BLOCK_INPUT ();
        !           744: #ifdef XDEBUG
        !           745:   fprintf (stderr, "XTupdate_begin\n");
        !           746: #endif
        !           747: 
        !           748:   InUpdate = 1;
        !           749:   if (CursorExists)
        !           750:     {
        !           751:       CursorToggle ();
        !           752:     }
        !           753:   SavedX = cursor_hpos;                /* The initial"hardware" cursor position is */
        !           754:   /*  saved because that is where gnu emacs */
        !           755:   /*  expects the cursor to be at the end of*/
        !           756:   /* the update */
        !           757:   SavedY = cursor_vpos;
        !           758:   dumpqueue ();
        !           759:   UNBLOCK_INPUT ();
        !           760: }
        !           761: 
        !           762: 
        !           763: static
        !           764: XTupdate_end ()
        !           765: {
        !           766:   BLOCK_INPUT_DECLARE ()
        !           767: 
        !           768:   BLOCK_INPUT ();
        !           769: #ifdef XDEBUG
        !           770:   fprintf (stderr, "XTupdate_end\n");
        !           771: #endif
        !           772:   if (CursorExists)
        !           773:     CursorToggle ();
        !           774:   InUpdate = 0;
        !           775:   dumpqueue ();
        !           776:   XTmove_cursor (SavedY, SavedX);      /* XTmove_cursor invokes cursor toggle */
        !           777:   UNBLOCK_INPUT ();
        !           778: }
        !           779: 
        !           780: /* Used for expose region and expose copy events.  Have to get the text
        !           781:  * back into the newly blank areas.
        !           782:  */
        !           783: 
        !           784: dumprectangle (top, left, rows, cols)
        !           785:      register int top, left, rows, cols;
        !           786: {
        !           787:   register int index;
        !           788:   int localX, localY, localHL;
        !           789:   rows += top;
        !           790:   cols += left;
        !           791:   top /= fontinfo->height;
        !           792:   /* Get row and col containing up and */
        !           793:   /* left borders of exposed region -- */
        !           794:   /* round down here*/
        !           795:   left /= fontinfo->width;
        !           796:   rows += (fontinfo->height - 1);
        !           797:   cols += (fontinfo->width - 1);
        !           798:   rows /= fontinfo->height;
        !           799:   /* Get row and col containing bottom and */
        !           800:   /* right borders -- round up here */
        !           801:   rows -= top;
        !           802:   cols /= fontinfo->width;
        !           803:   cols -= left;
        !           804:   if (rows < 0) return;
        !           805:   if (cols < 0) return;
        !           806:   if (top > (screen_height - 1)) return;
        !           807:   if (left > (screen_width - 1)) return;
        !           808:   if ((VisibleX >= left) && (VisibleX < (left + cols)) &&
        !           809:       (VisibleY >= top) && (VisibleY < (top + rows)))
        !           810:     {
        !           811:       ClearCursor ();
        !           812:     }
        !           813: 
        !           814:   /* should perhaps be DesiredScreen */
        !           815:   /* but PhysScreen is guaranteed to contain*/
        !           816:   /* date which was good for every line on */
        !           817:   /* screen. For desired screen only for */
        !           818:   /* lines which are changing.  Emacs does */
        !           819:   /* not consider a line within a newly */
        !           820:   /* exposed region necessarily to have */
        !           821:   /* been changed.  Emacs knows nothing */
        !           822:   /* about ExposeRegion events.*/
        !           823:   for (localY = top, index = 0;
        !           824:        (index < rows) && (localY < screen_height);
        !           825:        ++index, ++localY)
        !           826:     {
        !           827:       if ((localY < 0) || (localY >= screen_height)) continue;
        !           828:       if (!current_screen->enable[localY]) continue;
        !           829:       if ((left + 1) > current_screen->used[localY]) continue;
        !           830:       localX = left;
        !           831:       localHL = current_screen->highlight[localY];
        !           832:       dumpchars (current_screen,
        !           833:                 min (cols,
        !           834:                      current_screen->used[localY]
        !           835:                        - localX),
        !           836:                 localX, localY, localHL);
        !           837:     }
        !           838:   if (!InUpdate && !CursorExists) CursorToggle ();
        !           839:   /* Routine usually called */
        !           840:   /* when not in update */
        !           841: }
        !           842: 
        !           843: /* What sections of the window will be modified from the UpdateDisplay
        !           844:  * routine is totally under software control.  Any line with Y coordinate
        !           845:  * greater than flexlines will not change during an update.  This is really
        !           846:  * used only during dellines and inslines routines (scraplines and stufflines)
        !           847:  */
        !           848: static
        !           849: XTset_terminal_window (n)
        !           850:      register int n;
        !           851: {
        !           852: #ifdef XDEBUG
        !           853:   fprintf (stderr, "XTset_terminal_window\n");
        !           854: #endif
        !           855:   if ((n <= 0) || (n > screen_height))
        !           856:     flexlines = screen_height;
        !           857:   else
        !           858:     flexlines = n;
        !           859: }
        !           860: 
        !           861: XTins_del_lines (vpos, n)
        !           862:      int vpos, n;
        !           863: {
        !           864: #ifdef XDEBUG
        !           865:   fprintf (stderr, "XTins_del_lines\n");
        !           866: #endif
        !           867:   XTmove_cursor (vpos, 0);
        !           868:   if (n >= 0) stufflines (n);
        !           869:   else scraplines (-n);
        !           870: }
        !           871: 
        !           872: static
        !           873: XTinsert_chars (start, len)
        !           874:      register char *start;
        !           875:      register int len;
        !           876: {
        !           877: #ifdef XDEBUG
        !           878:   fprintf (stderr, "XTinsert_chars\n");
        !           879: #endif
        !           880:   writechars (start, start + len - 1);
        !           881: }
        !           882: 
        !           883: static
        !           884: XTdelete_chars (n)
        !           885:      register int n;
        !           886: {
        !           887:   char *msg = "***Delete Chars Called Outside of Update!!!***";
        !           888: #ifdef XDEBUG
        !           889:   fprintf (stderr, "XTdelete_chars\n");
        !           890: #endif
        !           891:   writechars (msg, msg + strlen (msg) - 1);
        !           892: }
        !           893: 
        !           894: static
        !           895: stufflines (n)
        !           896:      register int n;
        !           897: {
        !           898:   register int topregion, bottomregion;
        !           899:   register int length, newtop;
        !           900:   BLOCK_INPUT_DECLARE ()
        !           901: 
        !           902:   if (cursor_vpos >= flexlines)
        !           903:     return;
        !           904: 
        !           905:   if (!WindowMapped)
        !           906:     {
        !           907:       bitblt = 0;
        !           908:       return;
        !           909:     }
        !           910:   BLOCK_INPUT ();
        !           911:   if (CursorExists) CursorToggle ();
        !           912:   dumpqueue ();
        !           913:   UNBLOCK_INPUT ();
        !           914:   topregion = cursor_vpos;
        !           915:   bottomregion = flexlines - (n + 1);
        !           916:   newtop = cursor_vpos + n;
        !           917:   length = (bottomregion - topregion) + 1;
        !           918:   if ((length > 0) && (newtop <= flexlines))
        !           919:     {
        !           920:       BLOCK_INPUT ();
        !           921:       /* Should already have cleared */
        !           922:       /* queue of events associated */
        !           923:       /* with old bitblts */
        !           924:       XMoveArea (XXwindow, XXInternalBorder,
        !           925:                 topregion * fontinfo->height+XXInternalBorder,
        !           926:                 XXInternalBorder, newtop * fontinfo->height+XXInternalBorder,
        !           927:                 screen_width * fontinfo->width,
        !           928:                 length * fontinfo->height);
        !           929:       if (WindowMapped)
        !           930:        bitblt = 1;
        !           931:       XFlush ();
        !           932:       UNBLOCK_INPUT ();
        !           933:       SIGNAL_INPUT_WHILE (bitblt);
        !           934:       XFlush ();
        !           935:     }
        !           936:   newtop = min (newtop, (flexlines - 1));
        !           937:   length = newtop - topregion;
        !           938:   if (length > 0)
        !           939:     {
        !           940:       XPixSet (XXwindow,
        !           941:               XXInternalBorder,
        !           942:               topregion * fontinfo->height+XXInternalBorder,
        !           943:               screen_width * fontinfo->width,
        !           944:               n * fontinfo->height,
        !           945:               back);
        !           946:     }
        !           947:   /*  if (!InUpdate) CursorToggle (); */
        !           948: }
        !           949: 
        !           950: static
        !           951: scraplines (n)
        !           952:      register int n;
        !           953: {
        !           954:   BLOCK_INPUT_DECLARE ()
        !           955:   if (!WindowMapped)
        !           956:     {
        !           957:       bitblt = 0;
        !           958:       return;
        !           959:     }
        !           960: 
        !           961:   if (cursor_vpos >= flexlines)
        !           962:     return;
        !           963:   BLOCK_INPUT ();
        !           964:   if (CursorExists) CursorToggle ();
        !           965:   dumpqueue ();
        !           966:   if ((cursor_vpos + n) >= flexlines)
        !           967:     {
        !           968:       if (flexlines >= (cursor_vpos + 1))
        !           969:        {
        !           970:          XPixSet (XXwindow,
        !           971:                   XXInternalBorder, cursor_vpos * fontinfo->height+XXInternalBorder,
        !           972:                   screen_width * fontinfo->width,
        !           973:                   (flexlines - cursor_vpos) * fontinfo->height,
        !           974:                   back);
        !           975:        }
        !           976:       UNBLOCK_INPUT ();
        !           977:     }
        !           978:   else
        !           979:     {
        !           980:       XMoveArea (XXwindow,
        !           981:                 XXInternalBorder,
        !           982:                 (cursor_vpos + n) * fontinfo->height+XXInternalBorder,
        !           983:                 XXInternalBorder, cursor_vpos * fontinfo->height+XXInternalBorder,
        !           984:                 screen_width * fontinfo->width,
        !           985:                 (flexlines - (cursor_vpos + n)) * fontinfo->height);
        !           986:       if (WindowMapped)
        !           987:        bitblt = 1;
        !           988:       XFlush ();
        !           989:       UNBLOCK_INPUT ();
        !           990:       SIGNAL_INPUT_WHILE (bitblt);
        !           991:       BLOCK_INPUT ();
        !           992:       XFlush ();
        !           993:       XPixSet (XXwindow, XXInternalBorder,
        !           994:               (flexlines - n) * fontinfo->height+XXInternalBorder,
        !           995:               screen_width * fontinfo->width,
        !           996:               n * fontinfo->height, back);
        !           997:       UNBLOCK_INPUT ();
        !           998:     }
        !           999:   /* if (!InUpdate) CursorToggle (); */
        !          1000: }
        !          1001: 
        !          1002: /* Substitutes for standard read routine.  Under X not interested in individual
        !          1003:  * bytes but rather individual packets.
        !          1004:  */
        !          1005: 
        !          1006: XTread_socket (sd, bufp, numchars)
        !          1007:      register int sd;
        !          1008:      register char *bufp;
        !          1009:      register int numchars;
        !          1010: {
        !          1011: 
        !          1012:   int count;
        !          1013:   char *where_mapping;
        !          1014:   int nbytes;
        !          1015:   int stuffpending;
        !          1016:   int temp_width, temp_height;
        !          1017:   BLOCK_INPUT_DECLARE ()
        !          1018:   /* XKeyPressedEvent event; */
        !          1019:   /*  typedef struct reply {XEvent event; struct reply *next} Reply;
        !          1020:       Reply *replies = NULL;*/
        !          1021: 
        !          1022:   BLOCK_INPUT ();
        !          1023:   count = 0;
        !          1024:   if (numchars <= 0)
        !          1025:     {  /* To keep from overflowing read buffer */
        !          1026:       numchars = 1;
        !          1027:       --bufp;
        !          1028:     }
        !          1029: #ifdef SIGIO
        !          1030:   while (bitblt || XPending () != 0)
        !          1031: #else
        !          1032: #ifndef HAVE_SELECT
        !          1033:   if (! (fcntl (fileno (stdin), F_GETFL, 0) & O_NDELAY))
        !          1034:     {
        !          1035:       extern int read_alarm_should_throw;
        !          1036:       if (CursorExists)
        !          1037:        xfixscreen ();
        !          1038:       read_alarm_should_throw = 1;
        !          1039:       XPeekEvent (&XXEvent);
        !          1040:       read_alarm_should_throw = 0;
        !          1041:     }
        !          1042: #endif
        !          1043:   while (XPending () != 0)
        !          1044: #endif
        !          1045:     {
        !          1046:       /* while there are more events*/
        !          1047:       XNextEvent (&XXEvent);
        !          1048:       switch (XXEvent.type)
        !          1049:        {
        !          1050: /*     case X_Reply:
        !          1051:        {
        !          1052:        extern char *malloc ();
        !          1053:        Reply *reply = (Reply *) malloc (sizeof (Reply));
        !          1054:        reply->next = replies;
        !          1055:        reply->event = XXEvent;
        !          1056:        replies = reply;
        !          1057:        break;
        !          1058:        }*/
        !          1059:        default:
        !          1060:          break;
        !          1061:        case ExposeWindow:
        !          1062:          if (((XExposeEvent *)&XXEvent)->window == XXIconWindow)
        !          1063:            {
        !          1064:              PendingIconExposure = 1;
        !          1065:            }
        !          1066:          else
        !          1067:            PendingExposure = 1;/* No reason to repeat */
        !          1068:          /* this if several */
        !          1069:          /* ExposeWindow events */
        !          1070:          /* come in quick succes-*/
        !          1071:          /* ion */
        !          1072:          break;
        !          1073:        case ExposeRegion:
        !          1074:          if (PendingExposure)
        !          1075:            {   /* Don't bother with */
        !          1076:              /* region events when */
        !          1077:              /* full window event */
        !          1078:              /* is pending */
        !          1079:              break;
        !          1080:            }
        !          1081:          loadxrepbuffer (&XXEvent, &XXqueue);
        !          1082:          if (XXqueue.rindex == XXqueue.windex)
        !          1083:            {
        !          1084:              PendingExposure = 1;
        !          1085:            }
        !          1086:          if ((XXqueue.rindex > XXqueue.mindex) ||
        !          1087:              (XXqueue.windex > XXqueue.mindex) ||
        !          1088:                (XXqueue.rindex < 0) ||
        !          1089:                  (XXqueue.windex < 0))
        !          1090:            {
        !          1091:              PendingExposure = 1;
        !          1092:            }
        !          1093:          break;
        !          1094:        case ExposeCopy:        /* For ExposeCopy sync */
        !          1095:          /* will block all outgoing */
        !          1096:          /* requests until this is */
        !          1097:          /* decremented */
        !          1098:          if (WindowMapped) bitblt = 0;
        !          1099:          break;
        !          1100:        case KeyPressed:
        !          1101:          /* bcopy (XXEvent, event, sizeof (XKeyPressedEvent)); */
        !          1102:          where_mapping = XLookupMapping (&XXEvent, &nbytes);
        !          1103:          /* Nasty fix for arrow keys */
        !          1104:          if (!nbytes && IsCursorKey (XXEvent.detail & 0xff))
        !          1105:            {
        !          1106:              switch (XXEvent.detail & 0xff)
        !          1107:                {
        !          1108:                case KC_CURSOR_LEFT:
        !          1109:                  where_mapping = "\002";
        !          1110:                  break;
        !          1111:                case KC_CURSOR_RIGHT:
        !          1112:                  where_mapping = "\006";
        !          1113:                  break;
        !          1114:                case KC_CURSOR_UP:
        !          1115:                  where_mapping = "\020";
        !          1116:                  break;
        !          1117:                case KC_CURSOR_DOWN:
        !          1118:                  where_mapping = "\016";
        !          1119:                  break;
        !          1120:                }
        !          1121:              nbytes = 1;
        !          1122:            }
        !          1123:          if (numchars - nbytes > 0)
        !          1124:            {
        !          1125:              bcopy (where_mapping, bufp, nbytes);
        !          1126:              bufp += nbytes;
        !          1127:              count += nbytes;
        !          1128:              numchars -= nbytes;
        !          1129:            }
        !          1130: /*       else
        !          1131:            {
        !          1132:              bcopy (where_mapping, bufp, numchars);
        !          1133:              bufp += numchars;
        !          1134:              count += numchars;
        !          1135:              numchars = 0;
        !          1136:              *(bufp-1) = *(where_mapping + nbytes - 1);
        !          1137:            }*/
        !          1138:          break;
        !          1139:        case ButtonPressed:
        !          1140:        case ButtonReleased:
        !          1141:          switch (spacecheck (Xxrepbuffer.mindex,
        !          1142:                              Xxrepbuffer.rindex,
        !          1143:                              Xxrepbuffer.windex, 0))
        !          1144:            {
        !          1145:            case 0:
        !          1146:              loadxrepbuffer (&XXEvent,
        !          1147:                              &Xxrepbuffer);
        !          1148:              if (informflag && (numchars > 1))
        !          1149:                {
        !          1150:                  *bufp++ = (char) 'X' & 037; /* C-x */
        !          1151:                  ++count;
        !          1152:                  --numchars;
        !          1153:                  *bufp++ = (char) 0;  /* C-@ */
        !          1154:                  ++count;
        !          1155:                  --numchars;
        !          1156:                }
        !          1157:              break;
        !          1158:            case -1:
        !          1159:              break;
        !          1160:            case -2:
        !          1161:            default:
        !          1162:              fixxrepbuffer ();
        !          1163:              break;
        !          1164:            }
        !          1165:          break;
        !          1166:        }
        !          1167:     }
        !          1168: /*  while (replies) {
        !          1169:     Reply *reply = replies;
        !          1170:     XPutBackEvent (&reply->event);
        !          1171:     replies = reply->next;
        !          1172:     free (reply);
        !          1173:     }*/
        !          1174:   if (count < 0)
        !          1175:     count = 0;
        !          1176: #ifdef HAVE_SELECT
        !          1177:   if (CursorExists
        !          1178: #ifdef O_NDELAY
        !          1179: #ifdef F_GETFL
        !          1180:       && (! (fcntl (fileno (stdin), F_GETFL, 0) & O_NDELAY))
        !          1181: #endif
        !          1182: #endif
        !          1183:       )
        !          1184:     xfixscreen ();
        !          1185: #endif
        !          1186:   UNBLOCK_INPUT ();
        !          1187:   return count;
        !          1188: }
        !          1189: 
        !          1190: /* refresh bitmap kitchen sink icon */
        !          1191: refreshicon ()
        !          1192: {
        !          1193:   BLOCK_INPUT_DECLARE ()
        !          1194: 
        !          1195:   BLOCK_INPUT ();
        !          1196:   if (XXIconWindow)
        !          1197:     XBitmapBitsPut (XXIconWindow, 0,  0, sink_width, sink_height,
        !          1198:                    sink_bits, BlackPixel, WhitePixel,
        !          1199:                    XXIconMask, GXcopy, AllPlanes);
        !          1200:   XFlush ();
        !          1201:   UNBLOCK_INPUT ();
        !          1202: }
        !          1203: 
        !          1204: XBitmapIcon ()
        !          1205: {
        !          1206:   BLOCK_INPUT_DECLARE ()
        !          1207: 
        !          1208:   BLOCK_INPUT ();
        !          1209:   if (!IconWindow)
        !          1210:     {
        !          1211:       XSetIconWindow (XXwindow,XXIconWindow);
        !          1212:       XSelectInput (XXIconWindow, ExposeWindow);
        !          1213:       IconWindow = !IconWindow;
        !          1214:     }
        !          1215:   UNBLOCK_INPUT ();
        !          1216: }
        !          1217: 
        !          1218: XTextIcon ()
        !          1219: {
        !          1220:   BLOCK_INPUT_DECLARE ()
        !          1221: 
        !          1222:   BLOCK_INPUT ();
        !          1223:   if (IconWindow)
        !          1224:     {
        !          1225:       XClearIconWindow (XXwindow);
        !          1226:       XSelectInput (XXIconWindow, NoEvent);
        !          1227:       IconWindow = !IconWindow;
        !          1228:     }
        !          1229:   UNBLOCK_INPUT ();
        !          1230: }
        !          1231: 
        !          1232: /* Interpreting incoming keycodes. Should have table modifiable as needed
        !          1233:  * from elisp.
        !          1234:  */
        !          1235: 
        !          1236: /* Exit gracefully from gnuemacs, doing an autosave and giving a status.
        !          1237:  */
        !          1238: 
        !          1239: XExitGracefully (disp, event)
        !          1240:      Display *disp;
        !          1241:      XErrorEvent *event;
        !          1242: {
        !          1243:   XCleanUp ();
        !          1244:   exit (70);
        !          1245: }
        !          1246: 
        !          1247: x_io_error (disp)
        !          1248:      Display *disp;
        !          1249: {
        !          1250:   XCleanUp ();
        !          1251:   exit (71);
        !          1252: }
        !          1253: 
        !          1254: #if 0
        !          1255: /* This kludge overcomes the failure to handle EAGAIN and EINTR
        !          1256:    in a certain version of X for 386 running system V.  */
        !          1257: 
        !          1258: x_io_error (disp, a, b, c, nwrite)
        !          1259:      Display *disp;
        !          1260: {
        !          1261:   extern _XSend ();
        !          1262:   unsigned int pc = ((unsigned int *)&disp)[-1];
        !          1263:   if (pc - (unsigned int)&_XSend - 100 < 100
        !          1264:        && (errno == EAGAIN || errno == EINTR))
        !          1265:     {
        !          1266:       /* We were called by `writedata' erroneously.
        !          1267:         Modify a local variable which `writedata'
        !          1268:         will subtract from the number of bytes to be written.  */
        !          1269:       nwrite = 0;
        !          1270:       return;
        !          1271:     }
        !          1272:   abort ();
        !          1273: }
        !          1274: #endif
        !          1275: 
        !          1276: xfixscreen ()
        !          1277: {
        !          1278:   register int temp_width, temp_height;
        !          1279:   BLOCK_INPUT_DECLARE ()
        !          1280:   /* register int temp_x, temp_y; */
        !          1281: 
        !          1282:   BLOCK_INPUT ();
        !          1283:   dumpqueue ();
        !          1284:   /* Check that the connection is in fact open.  This works by doing a nop */
        !          1285:   /* (well, almost) write operation.  If there is an XIOerror or a */
        !          1286:   /* SIGPIPE, exit gracefully.  This fixes the loop-on-logout bug.*/
        !          1287:   /* XIOErrorHandler (XExitGracefully); */
        !          1288:   XPixFill (XXwindow, 0, 0, 1, 1, back, ClipModeClipped, GXnoop, AllPlanes);
        !          1289:   XFlush ();
        !          1290:   /* XIOErrorHandler (0); */
        !          1291:   if (PendingIconExposure)
        !          1292:     {
        !          1293:       refreshicon ();
        !          1294:       PendingIconExposure = 0;
        !          1295:     }
        !          1296:   if (PendingExposure)
        !          1297:     {
        !          1298:       PendingExposure = 0;
        !          1299:       ClearCursor ();
        !          1300:       XXqueue.rindex = 0;
        !          1301:       XXqueue.windex = 0;
        !          1302:       XQueryWindow (XXwindow, &windowinfo); /* Dangerous to do */
        !          1303:       /* writes here but */
        !          1304:       /* otherwise would */
        !          1305:       /* have to alter */
        !          1306:       /* gnu emacs display */
        !          1307:       /* routines to query */
        !          1308:       /* when screen garbaged */
        !          1309:       temp_width = (windowinfo.width - 2 * XXInternalBorder) / fontinfo->width;
        !          1310:       temp_height = (windowinfo.height- 2*XXInternalBorder) / fontinfo->height;
        !          1311:       if (temp_width != screen_width || temp_height != screen_height)
        !          1312:        change_screen_size (max (5, temp_height), max (10, temp_width),
        !          1313:                            0, 0, 0);
        !          1314:       XXxoffset= windowinfo.x;
        !          1315:       XXyoffset = windowinfo.y;
        !          1316:       /*if (temp_x != XXxoffset || temp_y != XXyoffset)
        !          1317:        XSetOffset (temp_x, temp_y);*/
        !          1318:       dumprectangle (0, 0,
        !          1319:                     screen_height * fontinfo->height + 2 * XXInternalBorder,
        !          1320:                     screen_width * fontinfo->width + 2 * XXInternalBorder);
        !          1321:     }
        !          1322:   if (!InUpdate)
        !          1323:     if (!CursorExists)
        !          1324:       CursorToggle ();
        !          1325:   XFlush ();
        !          1326:   UNBLOCK_INPUT ();
        !          1327:   SIGNAL_INPUT ();
        !          1328: }
        !          1329: 
        !          1330: x_term_init ()
        !          1331: {
        !          1332:   char *vardisplay;
        !          1333:   char *temp_font;
        !          1334:   register char *option;
        !          1335:   extern XTinterrupt_signal ();
        !          1336:   int reversevideo;
        !          1337:   Color cdef;
        !          1338:   char *progname;
        !          1339: 
        !          1340:   Fset (intern ("window-system-version"), make_number (10));
        !          1341: 
        !          1342:   vardisplay = (alternate_display ? alternate_display
        !          1343:                : (char *) egetenv ("DISPLAY"));
        !          1344:   if (!vardisplay || *vardisplay == '\0')
        !          1345:     {
        !          1346:       fprintf (stderr, "DISPLAY environment variable must be set\n");
        !          1347:       exit (-200);
        !          1348:     }
        !          1349: 
        !          1350:   XXdisplay = XOpenDisplay (vardisplay);
        !          1351:   if (XXdisplay == (Display *) 0)
        !          1352:     {
        !          1353:       fprintf (stderr, "X server not responding.  Check your DISPLAY environment variable.\n");
        !          1354:       exit (-200);
        !          1355:     }
        !          1356:   x_init_1 (1);
        !          1357:   Xxrepbuffer.mindex = XREPBUFSIZE - 1;
        !          1358:   Xxrepbuffer.windex = 0;
        !          1359:   Xxrepbuffer.rindex = 0;
        !          1360:   XXqueue.mindex = XREPBUFSIZE - 1;
        !          1361:   XXqueue.windex = 0;
        !          1362:   XXqueue.rindex = 0;
        !          1363:   WindowMapped = 0;
        !          1364:   baud_rate = 9600;
        !          1365:   min_padding_speed = 10000;
        !          1366:   must_write_spaces = 1;
        !          1367:   informflag = 1;
        !          1368:   meta_key = 1;
        !          1369:   visible_bell = 1;
        !          1370: #ifdef SIGIO
        !          1371:   interrupt_input = 1;
        !          1372: #endif
        !          1373:   inverse_video = 1;
        !          1374:   bitblt = 0;
        !          1375:   PendingExposure = 0;
        !          1376: 
        !          1377:   fix_screen_hook = xfixscreen;
        !          1378:   clear_screen_hook = XTclear_screen;
        !          1379:   clear_end_of_line_hook = XTclear_end_of_line;
        !          1380:   ins_del_lines_hook = XTins_del_lines;
        !          1381:   change_line_highlight_hook = XTchange_line_highlight;
        !          1382:   insert_chars_hook = XTinsert_chars;
        !          1383:   output_chars_hook = XToutput_chars;
        !          1384:   delete_chars_hook = XTdelete_chars;
        !          1385:   ring_bell_hook = XTfeep;
        !          1386:   reset_terminal_modes_hook = XTreset_terminal_modes;
        !          1387:   set_terminal_modes_hook = XTset_terminal_modes;
        !          1388:   update_begin_hook = XTupdate_begin;
        !          1389:   update_end_hook = XTupdate_end;
        !          1390:   set_terminal_window_hook = XTset_terminal_window;
        !          1391:   read_socket_hook = XTread_socket;
        !          1392:   move_cursor_hook = XTmove_cursor;
        !          1393:   /* raw_move_cursor_hook = XTraw_move_cursor;  */
        !          1394:   reassert_line_highlight_hook = XTreassert_line_highlight;
        !          1395:   scroll_region_ok = 1;        /* we'll scroll partial screens */
        !          1396:   char_ins_del_ok = 0;         /* just as fast to write the line */
        !          1397:   line_ins_del_ok = 1;         /* we'll just blt 'em */
        !          1398:   fast_clear_end_of_line = 1;  /* X does this well */
        !          1399:   memory_below_screen = 0;     /* we don't remember what scrolls
        !          1400:                                   off the bottom */
        !          1401:   dont_calculate_costs = 1;
        !          1402: 
        !          1403:   /* New options section */
        !          1404:   IconWindow = 0;
        !          1405:   XXborder = 1;
        !          1406:   XXInternalBorder = 1;
        !          1407:   screen_width = 80;
        !          1408:   screen_height = 66;
        !          1409:   reversevideo = 0;
        !          1410:   XXxoffset = 0;
        !          1411:   XXyoffset = 0;
        !          1412:   XXdebug = 0;
        !          1413: 
        !          1414:   XErrorHandler (XExitGracefully);
        !          1415:   XIOErrorHandler (x_io_error);
        !          1416: 
        !          1417:   progname = "emacs";
        !          1418:   if (option = XGetDefault (progname,"ReverseVideo"))
        !          1419:     if (strcmp (option,"on") == 0) reversevideo = 1;
        !          1420:   if (option = XGetDefault (progname, "BitmapIcon"))
        !          1421:     if (strcmp (option, "on") == 0) IconWindow = 1;
        !          1422: 
        !          1423:   if (option = XGetDefault (progname,"BorderWidth"))
        !          1424:     XXborder = atoi (option);
        !          1425:   if (option = XGetDefault (progname,"InternalBorder"))
        !          1426:     XXInternalBorder = atoi (option);
        !          1427: 
        !          1428:   brdr_color = XGetDefault (progname,"Border");
        !          1429:   if (!brdr_color) brdr_color = XGetDefault (progname, "BorderColor");
        !          1430:   back_color = XGetDefault (progname,"Background");
        !          1431:   fore_color = XGetDefault (progname,"Foreground");
        !          1432:   mous_color = XGetDefault (progname,"Mouse");
        !          1433:   curs_color = XGetDefault (progname,"Cursor");
        !          1434: 
        !          1435:   temp_font  = XGetDefault (progname,"BodyFont");
        !          1436:   if (temp_font == 0) temp_font = X_DEFAULT_FONT;
        !          1437:   XXcurrentfont = (char *) xmalloc (strlen (temp_font) + 1);
        !          1438:   strcpy (XXcurrentfont, temp_font);
        !          1439: 
        !          1440:   /* If user has specified a special keymap for use with Emacs, use it. */
        !          1441:   {
        !          1442:     char *temp = XGetDefault (progname, "KeyMap");
        !          1443:     if (temp) XUseKeymap (temp);
        !          1444:   }
        !          1445: 
        !          1446:   if (DisplayCells () > 2)
        !          1447:     {
        !          1448: 
        !          1449:       if (fore_color && XParseColor (fore_color, &cdef) &&
        !          1450:          XGetHardwareColor (&cdef))
        !          1451:        fore = cdef.pixel;
        !          1452:       else
        !          1453:        {
        !          1454:          fore_color = "black";
        !          1455:          fore = BlackPixel;
        !          1456:        }
        !          1457: 
        !          1458:       if (back_color && XParseColor (back_color, &cdef) &&
        !          1459:          XGetHardwareColor (&cdef))
        !          1460:        back = cdef.pixel;
        !          1461:       else
        !          1462:        {
        !          1463:          back_color = "white";
        !          1464:          back = WhitePixel;
        !          1465:        }
        !          1466: 
        !          1467:       if (curs_color && XParseColor (curs_color, &cdef) &&
        !          1468:          XGetHardwareColor (&cdef))
        !          1469:        curs = cdef.pixel;
        !          1470:       else
        !          1471:        {
        !          1472:          curs_color = "black";
        !          1473:          curs = BlackPixel;
        !          1474:        }
        !          1475: 
        !          1476:       if (mous_color && XParseColor (mous_color, &cdef) &&
        !          1477:          XGetHardwareColor (&cdef))
        !          1478:        mous = cdef.pixel;
        !          1479:       else
        !          1480:        {
        !          1481:          mous_color = "black";
        !          1482:          mous = BlackPixel;
        !          1483:        }
        !          1484: 
        !          1485:       if (brdr_color && XParseColor (brdr_color, &cdef) &&
        !          1486:          XGetHardwareColor (&cdef))
        !          1487:        brdr = cdef.pixel;
        !          1488:       else
        !          1489:        {
        !          1490:          brdr_color = "black";
        !          1491:          brdr = BlackPixel;
        !          1492:        }
        !          1493:     }
        !          1494:   else
        !          1495:     {
        !          1496:       fore_color  = curs_color = mous_color = brdr_color = "black";
        !          1497:       fore = curs = mous = brdr = BlackPixel;
        !          1498:       back_color = "white";
        !          1499:       back = WhitePixel;
        !          1500:     }
        !          1501: 
        !          1502:   /*
        !          1503:   if (fore_color && DisplayCells () > 2 &&
        !          1504:       XParseColor (fore_color, &cdef) && XGetHardwareColor (&cdef))
        !          1505:     fore = cdef.pixel;
        !          1506:   else if (fore_color && strcmp (fore_color, "black") == 0)
        !          1507:     fore = BlackPixel;
        !          1508:   else if (fore_color && strcmp (fore_color, "white") == 0)
        !          1509:     fore = WhitePixel;
        !          1510:   else
        !          1511:     {
        !          1512:       fore_color = "black";
        !          1513:       fore = BlackPixel;
        !          1514:     }
        !          1515: 
        !          1516:   if (back_color && DisplayCells () > 2 &&
        !          1517:       XParseColor (back_color, &cdef) && XGetHardwareColor (&cdef))
        !          1518:     back = cdef.pixel;
        !          1519:   else if (back_color && strcmp (back_color, "white") == 0)
        !          1520:     back = WhitePixel;
        !          1521:   else if (back_color && strcmp (back_color, "black") == 0)
        !          1522:     back = BlackPixel;
        !          1523:   else
        !          1524:     {
        !          1525:       back_color = "white";
        !          1526:       back = WhitePixel;
        !          1527:     }
        !          1528: 
        !          1529:   if (brdr_color && DisplayCells () > 2 &&
        !          1530:       XParseColor (brdr_color, &cdef) && XGetHardwareColor (&cdef))
        !          1531:     brdr = cdef.pixel;
        !          1532:   else if (brdr_color && (!strcmp (brdr_color, "gray") ||
        !          1533:                          !strcmp (brdr_color, "grey") ||
        !          1534:                          !strcmp (brdr_color, "Gray") ||
        !          1535:                          !strcmp (brdr_color, "Grey")))
        !          1536:     brdr = BlackPixel;
        !          1537:   else if (brdr_color && strcmp (brdr_color, "white") == 0)
        !          1538:     brdr = WhitePixel;
        !          1539:   else
        !          1540:     {
        !          1541:       brdr_color = "black";
        !          1542:       brdr = BlackPixel;
        !          1543:     }
        !          1544: 
        !          1545:   if (curs_color && DisplayCells () > 2 &&
        !          1546:       XParseColor (curs_color, &cdef) && XGetHardwareColor (&cdef))
        !          1547:     curs = cdef.pixel;
        !          1548:   else if (curs_color && strcmp (curs_color, "black") == 0)
        !          1549:     curs = BlackPixel;
        !          1550:   else if (curs_color && strcmp (curs_color, "white") == 0)
        !          1551:     curs = WhitePixel;
        !          1552:   else
        !          1553:     {
        !          1554:       curs_color = "black";
        !          1555:       curs = BlackPixel;
        !          1556:     }
        !          1557: 
        !          1558:   if (mous_color && DisplayCells () > 2 &&
        !          1559:       XParseColor (mous_color, &cdef) && XGetHardwareColor (&cdef))
        !          1560:     mous = cdef.pixel;
        !          1561:   else if (mous_color && strcmp (mous_color, "black") == 0)
        !          1562:     mous = BlackPixel;
        !          1563:   else if (mous_color && strcmp (mous_color, "white") == 0)
        !          1564:     mous = WhitePixel;
        !          1565:   else
        !          1566:     {
        !          1567:       mous_color = "black";
        !          1568:       mous = BlackPixel;
        !          1569:     }
        !          1570:     */
        !          1571: 
        !          1572:   XXpid = getpid ();
        !          1573:   if (XXcurrentfont == (char *) 0)
        !          1574:     {
        !          1575:       fprintf (stderr, "Memory allocation failure.\n");
        !          1576:       exit (-150);
        !          1577:     }
        !          1578:   default_window = "=80x24+0+0";
        !          1579: /* RMS: XTread_socket does not have an interface suitable
        !          1580:    for being a signal handler.  In any case, the SIGIO handler is
        !          1581:    set up in init_keyboard and X uses the same one as usual.  */
        !          1582: /*  signal (SIGIO, XTread_socket); */
        !          1583:   signal (SIGPIPE, XExitGracefully);
        !          1584:   XQueryWindow (RootWindow, &rootwindowinfo);
        !          1585:   strncpy (iconidentity, ICONTAG, MAXICID);
        !          1586:   fontinfo = XOpenFont (XXcurrentfont);
        !          1587:   if (fontinfo == (FontInfo *) 0)
        !          1588:     {
        !          1589:       fprintf (stderr, "No font\n");
        !          1590:       exit (-98);
        !          1591:     }
        !          1592:   pixelwidth = screen_width * fontinfo->width + 2 * XXInternalBorder;
        !          1593:   pixelheight = screen_height * fontinfo->height + 2 * XXInternalBorder;
        !          1594:   XXwindow = XCreateWindow (RootWindow,
        !          1595:                            XXxoffset /* Absolute horizontal offset */,
        !          1596:                            XXyoffset /* Absolute Vertical offset */,
        !          1597:                            pixelwidth, pixelheight,
        !          1598:                            XXborder, BlackPixmap, WhitePixmap);
        !          1599:   if (!XXwindow)
        !          1600:     {
        !          1601:       fprintf (stderr, "Unable to create window.\n");
        !          1602:       exit (-97);
        !          1603:     }
        !          1604: 
        !          1605:   XXIconWindow = XCreateWindow (RootWindow, 0, 0, sink_width, sink_height,
        !          1606:                                2, WhitePixmap, (Pixmap) NULL);
        !          1607: 
        !          1608:   if (!XXIconWindow)
        !          1609:     {
        !          1610:       fprintf (stderr, "Unable to create icon window.\n");
        !          1611:       fflush (stderr);
        !          1612:       exit (-97);
        !          1613:     }
        !          1614:   XSelectInput (XXIconWindow, NoEvent);
        !          1615:   XXIconMask = XStoreBitmap (sink_mask_width, sink_mask_height, sink_mask_bits);
        !          1616: 
        !          1617:   XSelectInput (XXwindow, NoEvent);
        !          1618:   XSetResizeHint (XXwindow, 2 * XXInternalBorder, 2 * XXInternalBorder,
        !          1619:                  /* fontinfo->width * 1, fontinfo->height * 1, */
        !          1620:                  fontinfo->width, fontinfo->height);
        !          1621: 
        !          1622: #if defined (BSD) || defined (HPUX) || defined (IBMRTAIX)
        !          1623:   if (gethostname (&iconidentity[sizeof (ICONTAG) - 1],
        !          1624:                   (MAXICID - 1) - sizeof (ICONTAG)))
        !          1625: #endif
        !          1626:     {
        !          1627:       iconidentity[sizeof (ICONTAG) - 2] = '\0';
        !          1628:     }
        !          1629:   XStoreName (XXwindow, &iconidentity[0]);
        !          1630: 
        !          1631:   EmacsCursor = XCreateCursor (16, 16, MouseCursor, MouseMask,
        !          1632:                               0, 0, mous, back, GXcopy);
        !          1633:   XDefineCursor (XXwindow, EmacsCursor);
        !          1634:   flexlines = screen_height;
        !          1635: #if 0
        !          1636: /* Do not call XPopUpWindow here!  This is too early.
        !          1637:    It is supposed ot be called via the term-setup-hook
        !          1638:    and not until after lisp/term/x-win.el has had a chance
        !          1639:    to process the user's switches.
        !          1640:    I am not sure that there are any circumstances under which
        !          1641:    this should be done here  -- RMS.  */
        !          1642:   XPopUpWindow ();             /* This looks at Vxterm */
        !          1643: #endif /* 0 */
        !          1644:   if (reversevideo) XFlipColor ();
        !          1645: }
        !          1646: 
        !          1647: x_init_1 (unrequest)
        !          1648: {
        !          1649: #ifdef F_SETOWN
        !          1650:   extern int old_fcntl_owner;
        !          1651: #endif
        !          1652: #ifndef USG
        !          1653:   extern void init_sigio (), request_sigio (), unrequest_sigio ();
        !          1654: #endif
        !          1655: 
        !          1656:   dup2 (dpyno (), 0);
        !          1657:   close (dpyno ());
        !          1658:   dpyno () = 0;                        /* Looks a little strange?
        !          1659:                                   check the def of the macro;
        !          1660:                                   it is a genuine lvalue */
        !          1661: #ifndef USG
        !          1662:   init_sigio ();
        !          1663:   request_sigio ();
        !          1664: #endif /* USG */
        !          1665: #ifdef F_SETOWN
        !          1666:   old_fcntl_owner = fcntl (0, F_GETOWN, 0);
        !          1667: #ifdef F_SETOWN_SOCK_NEG
        !          1668:   fcntl (0, F_SETOWN, -getpid ());     /* stdin is a socket here */
        !          1669: #else
        !          1670:   fcntl (0, F_SETOWN, getpid ());
        !          1671: #endif /* F_SETOWN_SOCK_NEG */
        !          1672: #endif /* F_SETOWN */
        !          1673: #ifndef USG
        !          1674:   if (unrequest) unrequest_sigio ();
        !          1675: #endif
        !          1676: }
        !          1677: 
        !          1678: /* Process all queued ExposeRegion events. */
        !          1679: static
        !          1680: dumpqueue ()
        !          1681: {
        !          1682:   register int i;
        !          1683:   XExposeRegionEvent r;
        !          1684:   if ((XXqueue.rindex > XXqueue.mindex) ||
        !          1685:       (XXqueue.windex > XXqueue.mindex) ||
        !          1686:       (XXqueue.rindex < 0) ||
        !          1687:       (XXqueue.windex < 0))
        !          1688:     {
        !          1689:       PendingExposure = 1;
        !          1690:     }
        !          1691:   else
        !          1692:     while (XXqueue.rindex != XXqueue.windex)
        !          1693:       {
        !          1694:        if (CursorExists)
        !          1695:          CursorToggle ();
        !          1696:        unloadxrepbuffer (&r, &XXqueue);
        !          1697:        dumprectangle (r.y - XXInternalBorder, r.x - XXInternalBorder,
        !          1698:                       r.height, r.width);
        !          1699:       }
        !          1700: }
        !          1701: 
        !          1702: XSetFlash ()
        !          1703: {
        !          1704:   ring_bell_hook = XTflash;
        !          1705: }
        !          1706: 
        !          1707: XSetFeep ()
        !          1708: {
        !          1709:   ring_bell_hook = XTfeep;
        !          1710: }
        !          1711: 
        !          1712: XNewFont (newname)
        !          1713:      register char *newname;
        !          1714: {
        !          1715:   FontInfo *temp;
        !          1716:   BLOCK_INPUT_DECLARE ()
        !          1717: 
        !          1718:   BLOCK_INPUT ();
        !          1719:   XFlush ();
        !          1720:   if (XXdebug)
        !          1721:     fprintf (stderr, "Request id is %d\n", XXdisplay->request);
        !          1722:   temp = XOpenFont (newname);
        !          1723:   if (temp == (FontInfo *) 0)
        !          1724:     {
        !          1725:       UNBLOCK_INPUT_RESIGNAL ();
        !          1726:       return -1;
        !          1727:     }
        !          1728:   XCloseFont (fontinfo);
        !          1729:   fontinfo = temp;
        !          1730:   XSetResizeHint (XXwindow, 2*XXInternalBorder, 2*XXInternalBorder,
        !          1731:                  /* fontinfo->width * 1, fontinfo->height * 1, */
        !          1732:                  fontinfo->width, fontinfo->height);
        !          1733:   XSetWindowSize (screen_height, screen_width);
        !          1734:   UNBLOCK_INPUT_RESIGNAL ();
        !          1735:   return 0;
        !          1736: }
        !          1737: 
        !          1738: XFlipColor ()
        !          1739: {
        !          1740:   Pixmap temp;
        !          1741:   int tempcolor;
        !          1742:   char *tempname;
        !          1743:   Cursor temp_curs;
        !          1744:   BLOCK_INPUT_DECLARE ()
        !          1745: 
        !          1746:   BLOCK_INPUT ();
        !          1747:   CursorToggle ();
        !          1748:   temp = XMakeTile (fore);
        !          1749:   XChangeBackground (XXwindow, temp);
        !          1750:   XFreePixmap (temp);
        !          1751:   temp = XMakeTile (back);
        !          1752:   if (XXborder)
        !          1753:     XChangeBorder (XXwindow, temp);
        !          1754:   XFreePixmap (temp);
        !          1755:   brdr = back;
        !          1756:   brdr_color = back_color;
        !          1757:   tempcolor = fore;
        !          1758:   fore = back;
        !          1759:   back = tempcolor;
        !          1760:   tempname = fore_color ;
        !          1761:   fore_color = back_color;
        !          1762:   back_color = tempname;
        !          1763: /*  XPixFill (XXwindow, 0, 0, screen_width * fontinfo->width,
        !          1764:            screen_height * fontinfo->height, back, ClipModeClipped,
        !          1765:            GXcopy, AllPlanes);
        !          1766:   dumprectangle (0, 0, screen_height * fontinfo->height + 2 * XXInternalBorder,
        !          1767:   screen_width * fontinfo -> width + 2 * XXInternalBorder);*/
        !          1768:   XRedrawDisplay ();
        !          1769:   if (curs == WhitePixel)
        !          1770:     {
        !          1771:       curs = BlackPixel;
        !          1772:       curs_color = "black";
        !          1773:     }
        !          1774:   else if (curs == BlackPixel)
        !          1775:     {
        !          1776:       curs = WhitePixel;
        !          1777:       curs_color = "white";
        !          1778:     }
        !          1779:   if (mous == WhitePixel)
        !          1780:     {
        !          1781:       mous = BlackPixel;
        !          1782:       mous_color = "black";
        !          1783:     }
        !          1784:   else if (mous == BlackPixel)
        !          1785:     {
        !          1786:       mous = WhitePixel;
        !          1787:       mous_color = "white";
        !          1788:     }
        !          1789:   temp_curs = XCreateCursor (16, 16, MouseCursor, MouseMask, 0, 0,
        !          1790:                             mous, back, GXcopy);
        !          1791:   XUndefineCursor (XXwindow);
        !          1792:   XDefineCursor (XXwindow, temp_curs);
        !          1793:   XFreeCursor (EmacsCursor);
        !          1794:   bcopy (&temp_curs, &EmacsCursor, sizeof (Cursor));
        !          1795:   CursorToggle ();
        !          1796:   XFlush ();
        !          1797:   UNBLOCK_INPUT ();
        !          1798: }
        !          1799: 
        !          1800: XSetOffset (xoff, yoff)
        !          1801:      register int xoff, yoff;
        !          1802: {
        !          1803:   BLOCK_INPUT_DECLARE ()
        !          1804: 
        !          1805:   BLOCK_INPUT ();
        !          1806:   if (xoff < 0)
        !          1807:     {
        !          1808:       XXxoffset = rootwindowinfo.width + (++xoff) - pixelwidth - 4;
        !          1809:     }
        !          1810:   else
        !          1811:     {
        !          1812:       XXxoffset = xoff;
        !          1813:     }
        !          1814:   if (yoff < 0)
        !          1815:     {
        !          1816:       XXyoffset
        !          1817:        = rootwindowinfo.height + (++yoff) - pixelheight - 4;
        !          1818:     }
        !          1819:   else
        !          1820:     {
        !          1821:       XXyoffset = yoff;
        !          1822:     }
        !          1823:   XMoveWindow (XXwindow, XXxoffset, XXyoffset);
        !          1824:   UNBLOCK_INPUT ();
        !          1825:   /* XWarpMouse (XXwindow, pixelwidth >> 1, pixelheight >> 1); */
        !          1826: }
        !          1827: 
        !          1828: XSetWindowSize (rows, cols)
        !          1829:      register int rows, cols;
        !          1830: {
        !          1831:   /* if (rows < 3) rows = 24;
        !          1832:      if (cols < 1) cols = 80; */
        !          1833:   pixelwidth = cols * fontinfo->width + 2 * XXInternalBorder;
        !          1834:   pixelheight = rows * fontinfo->height + 2 * XXInternalBorder;
        !          1835:   XChangeWindow (XXwindow, pixelwidth, pixelheight);
        !          1836:   XFlush ();
        !          1837:   change_screen_size (rows, cols, 0, 0, 0);
        !          1838:   PendingExposure = 0;
        !          1839: }
        !          1840: 
        !          1841: XPopUpWindow ()
        !          1842: {
        !          1843:   BLOCK_INPUT_DECLARE ()
        !          1844:   if (WindowMapped)
        !          1845:     return;
        !          1846:   BLOCK_INPUT ();
        !          1847:   if (!x_edges_specified)
        !          1848:     Fx_rubber_band ();
        !          1849:   bitblt = 0;
        !          1850:   CursorExists = 0;
        !          1851:   VisibleX = 0;
        !          1852:   VisibleY = 0;
        !          1853:   WindowMapped = 1;
        !          1854:   XMapWindow (XXwindow);
        !          1855:   dumprectangle (0, 0,
        !          1856:                 screen_height * fontinfo->height + 2 * XXInternalBorder,
        !          1857:                 screen_width * fontinfo->width + 2 * XXInternalBorder);
        !          1858:   XSelectInput (XXwindow, KeyPressed | ExposeWindow | ButtonPressed
        !          1859:                | ButtonReleased
        !          1860:                | ExposeRegion | ExposeCopy);
        !          1861:   /*   XWarpMouse (XXwindow, pixelwidth >> 1, pixelheight >> 1);*/
        !          1862:   XTmove_cursor (0, 0);
        !          1863:   if (IconWindow)
        !          1864:     {
        !          1865:       XSetIconWindow (XXwindow,XXIconWindow);
        !          1866:       XSelectInput (XXIconWindow, ExposeWindow);
        !          1867:     }
        !          1868:   else
        !          1869:     {
        !          1870:       XClearIconWindow (XXwindow);
        !          1871:       XSelectInput (XXIconWindow, NoEvent);
        !          1872:     }
        !          1873:   /*  XRedrawDisplay ();*/
        !          1874:   XFlush ();
        !          1875:   UNBLOCK_INPUT ();
        !          1876: }
        !          1877: 
        !          1878: spacecheck (mindex, rindex, windex, minfreespace)
        !          1879:      register int mindex, rindex, windex, minfreespace;
        !          1880: {
        !          1881:   if ((rindex > mindex) || (windex > mindex))
        !          1882:     {
        !          1883:       /* fprintf (stderr, "Fatal Mouse Buffer Error.\n");
        !          1884:         fprintf (stderr, "%d = mindex, %d = rindex, %d = windex\n",
        !          1885:         mindex, rindex, windex); */
        !          1886:       return -2;
        !          1887:     }
        !          1888:   if (windex >= rindex)
        !          1889:     {
        !          1890:       if ((mindex - (windex - rindex)) > minfreespace)
        !          1891:        return 0;
        !          1892:     }
        !          1893:   else
        !          1894:     {
        !          1895:       if (((rindex - windex) - 1) > minfreespace)
        !          1896:        return 0;
        !          1897:     }
        !          1898:   return -1;
        !          1899: }
        !          1900: 
        !          1901: loadxrepbuffer (p_xrep, p_buffer)
        !          1902:      register XEvent *p_xrep;
        !          1903:      register XREPBUFFER *p_buffer;
        !          1904: {
        !          1905:   p_buffer->xrep[p_buffer->windex] = *p_xrep;
        !          1906:   if (p_buffer->windex == p_buffer->mindex)
        !          1907:     p_buffer->windex = 0;
        !          1908:   else
        !          1909:     p_buffer->windex++;
        !          1910: }
        !          1911: 
        !          1912: unloadxrepbuffer (p_xrep, p_buffer)
        !          1913:      register XEvent *p_xrep;
        !          1914:      register XREPBUFFER *p_buffer;
        !          1915: {
        !          1916:   if (p_buffer->windex == p_buffer->rindex)
        !          1917:     return -1;
        !          1918:   *p_xrep = p_buffer->xrep[p_buffer->rindex];
        !          1919:   if (p_buffer->rindex == p_buffer->mindex)
        !          1920:     p_buffer->rindex = 0;
        !          1921:   else
        !          1922:     p_buffer->rindex++;
        !          1923:   return 0;
        !          1924: }
        !          1925: 
        !          1926: fixxrepbuffer ()
        !          1927: {
        !          1928:   Xxrepbuffer.mindex = XREPBUFSIZE - 1;
        !          1929:   Xxrepbuffer.windex = 0;
        !          1930:   Xxrepbuffer.rindex = 0;
        !          1931: }
        !          1932: 
        !          1933: #endif /* HAVE_X_WINDOWS */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.