Return to scrollText.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / games / chess / Xchess / scrollText

Annotation of 43BSDReno/games/chess/Xchess/scrollText/scrollText.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * A Scrollable Text Output Window
        !             3:  *
        !             4:  * David Harrison 
        !             5:  * University of California,  Berkeley
        !             6:  * 1986
        !             7:  *
        !             8:  * The following is an implementation for a scrollable text output
        !             9:  * system.  It handles exposure events only (other interactions are
        !            10:  * under user control).  For scrolling,  a always present scroll bar
        !            11:  * is implemented.  It detects size changes and compensates accordingly.
        !            12:  */
        !            13: 
        !            14: #include <X11/X.h>
        !            15: #include <X11/Xlib.h>
        !            16: #include <X11/X10.h>
        !            17: #include <sys/types.h>
        !            18: #include "scrollText.h"
        !            19: 
        !            20: extern char *malloc();
        !            21: extern char *realloc();
        !            22: #define alloc(type)            (type *) malloc(sizeof(type))
        !            23: #define numalloc(type, num)    (type *) malloc((unsigned) (num * sizeof(type)))
        !            24: #define MAXINT         2147483647
        !            25: 
        !            26: extern XAssocTable *XCreateAssocTable();
        !            27: extern caddr_t XLookUpAssoc();
        !            28: 
        !            29: static XAssocTable *textWindows = (XAssocTable *) 0;
        !            30: 
        !            31: #define NOOPTION       -1      /* Option hasn't been set yet                */
        !            32: #define NORMSCROLL     0       /* Smooth scroll on LineToTop and TopToHere  */
        !            33: #define JUMPSCROLL     1       /* Jump scrolling on LineToTop and TopToHere */
        !            34: 
        !            35: static int ScrollOption = NOOPTION;
        !            36: 
        !            37: typedef char *Generic;
        !            38: 
        !            39: #define DEFAULT_GC textInfo->fontGC[textInfo->curFont]
        !            40: 
        !            41: #define BARSIZE                15
        !            42: #define BARBORDER      1
        !            43: #define MAXFONTS       8
        !            44: #define INITBUFSIZE    1024
        !            45: #define INITLINES      50
        !            46: #define INITEXPARY     50
        !            47: #define XPADDING       2
        !            48: #define YPADDING       2
        !            49: #define INTERLINE      5
        !            50: #define INTERSPACE     1
        !            51: #define CURSORWIDTH    2
        !            52: #define EXPANDPERCENT  40
        !            53: #define BUFSIZE                1024
        !            54: #define CUROFFSET      1
        !            55: #define MAXFOREIGN     250
        !            56: #define NOINDEX                -1
        !            57: 
        !            58: /* The wrap line indicator */
        !            59: #define WRAPINDSIZE    7
        !            60: #define STEMOFFSET     5
        !            61: #define arrow_width 7
        !            62: #define arrow_height 5
        !            63: static char arrow_bits[] = {
        !            64:    0x24, 0x26, 0x3f, 0x06, 0x04};
        !            65: 
        !            66: #define NEWLINE                '\n'
        !            67: #define BACKSPACE      '\010'
        !            68: #define NEWFONT                '\006'
        !            69: #define LOWCHAR                '\040'
        !            70: #define HIGHCHAR       '\176'
        !            71: 
        !            72: #define CHARMASK       0x00ff  /* Character mask */
        !            73: #define FONTMASK       0x0700  /* Character font */
        !            74: #define FONTSHIFT      8       /* Shift amount   */
        !            75: 
        !            76: #define WRAPFLAG       0x01    /* Line wrap flag */
        !            77: 
        !            78: /*
        !            79:  * Lines are represented by a pointer into the overall array of
        !            80:  * 16-bit characters.  The lower eight bits is used to indicate the character
        !            81:  * (in ASCII),  and the next two bits are used to indicate the font
        !            82:  * the character should be drawn in.
        !            83:  */
        !            84: 
        !            85: typedef struct txtLine {
        !            86:     int lineLength;            /* Current line length               */
        !            87:     int lineHeight;            /* Full height of line in pixels     */
        !            88:     int lineBaseLine;          /* Current baseline of the line      */
        !            89:     int lineWidth;             /* Drawing position at end of line   */
        !            90:     int lineText;              /* Offset into master buffer         */
        !            91:     int lineFlags;             /* Line wrap flag is here            */
        !            92: };
        !            93: 
        !            94: 
        !            95: /*
        !            96:  * For ExposeCopy events,  we queue up the redraw requests collapsing
        !            97:  * them into line redraw requests until the CopyExpose event arrives.
        !            98:  * The queue is represented as a dynamic array of the following
        !            99:  * structure:
        !           100:  */
        !           101: 
        !           102: typedef struct expEvent {
        !           103:     int lineIndex;             /* Index of line to redraw  */
        !           104:     int ypos;                  /* Drawing position of line */
        !           105: };
        !           106: 
        !           107: 
        !           108: /*
        !           109:  * The text buffer is represented using a dynamic counted array
        !           110:  * of 16-bit quantities. This array expands as needed.
        !           111:  * For the screen representation,  a dynamic counted array
        !           112:  * of line structures is used.  This array points into the
        !           113:  * text buffer to denote the start of each line and its parameters.
        !           114:  * The windows are configured as one overall window which contains
        !           115:  * the scroll bar as a sub-window along its right edge.  Thus,
        !           116:  * the text drawing space is actually w-BARSIZE.
        !           117:  */
        !           118: 
        !           119: #define NOTATBOTTOM    0x01    /* Need to scroll to bottom before appending */
        !           120: #define FONTNUMWAIT    0x02    /* Waiting for font number                   */
        !           121: #define COPYEXPOSE     0x04    /* Need to process a copy expose event       */
        !           122: #define SCREENWRONG    0x08    /* TxtJamStr has invalidated screen contents */
        !           123: 
        !           124: typedef struct txtWin {
        !           125:     /* Basic text buffer */
        !           126:     int bufAlloc;              /* Allocated size of buffer           */
        !           127:     int bufSpot;               /* Current writing position in buffer */
        !           128:     short *mainBuffer;         /* Main buffer of text                */
        !           129: 
        !           130:     /* Line information */
        !           131:     int numLines;              /* Number of display lines in buffer */
        !           132:     int allocLines;            /* Number of lines allocated         */
        !           133:     struct txtLine **txtBuffer;        /* Dynamic array of lines            */
        !           134: 
        !           135:     /* Current Window display information */
        !           136:     Window mainWindow;         /* Text display window       */
        !           137:     Window scrollBar;          /* Subwindow for scroll bar  */
        !           138:     Pixmap arrowMap;           /* line wrap indicator       */
        !           139:     int bgPix, fgPix;          /* Background and cursor     */
        !           140:     GC CursorGC;               /* gc for the cursor         */
        !           141:     GC bgGC;                   /* gc for erasing things     */
        !           142:     GC fontGC[MAXFONTS];       /* gc for doing fonts        */
        !           143:     XFontStruct theFonts[MAXFONTS];/* Display fonts          */
        !           144:     int  theColors[MAXFONTS];  /* foregrounds of the fonts  */
        !           145:     int  curFont;              /* current font for tracking */
        !           146:     int w, h;                  /* Current size              */
        !           147:     int startLine;             /* Top line in display       */
        !           148:     int endLine;               /* Bottom line in display    */
        !           149:     int bottomSpace;           /* Space at bottom of screen */
        !           150:     int flagWord;              /* If non-zero,  not at end  */
        !           151: 
        !           152:     /* For handling ExposeCopy events */
        !           153:     int exposeSize;            /* Current size of array      */
        !           154:     int exposeAlloc;           /* Allocated size             */
        !           155:     struct expEvent **exposeAry;/* Array of line indices      */
        !           156: 
        !           157:     /* Drawing position information */
        !           158:     int curLine;               /* Current line in buffer    */
        !           159:     int curX;                  /* Current horizontal positi */
        !           160:     int curY;                  /* Current vertical drawing  */
        !           161: };
        !           162: 
        !           163: /* Flags for the various basic character handling functions */
        !           164: 
        !           165: #define DODISP         0x01    /* Update the display  */
        !           166: #define NONEWLINE      0x02    /* Dont append newline */
        !           167: 
        !           168: 
        !           169: 
        !           170: static int InitLine(newLine)
        !           171: struct txtLine *newLine;       /* Newly created line structure */
        !           172: /*
        !           173:  * This routine initializes a newly created line structure.
        !           174:  */
        !           175: {
        !           176:     newLine->lineLength = 0;
        !           177:     newLine->lineHeight = 0;
        !           178:     newLine->lineBaseLine = 0;
        !           179:     newLine->lineWidth = XPADDING;
        !           180:     newLine->lineText = NOINDEX;
        !           181:     newLine->lineFlags = 0;
        !           182:     return 1;
        !           183: }
        !           184: 
        !           185: 
        !           186: 
        !           187: 
        !           188: int TxtGrab(display, txtWin, program, mainFont, bg, fg, cur)
        !           189: Display *display;              /* display window is on  */
        !           190: Window txtWin;                 /* Window to take over as scrollable text    */
        !           191: char *program;                 /* Program name for Xdefaults                */
        !           192: XFontStruct *mainFont;         /* Primary text font                         */
        !           193: int bg, fg, cur;               /* Background, foreground, and cursor colors */
        !           194: /*
        !           195:  * This routine takes control of 'txtWin' and makes it into a scrollable
        !           196:  * text output window.  It will create a sub-window for the scroll bar
        !           197:  * with a background of 'bg' and an bar with color 'fg'.  Both fixed width
        !           198:  * and variable width fonts are supported.  Additional fonts can be loaded
        !           199:  * using 'TxtAddFont'.  Returns 0 if there were problems,  non-zero if
        !           200:  * everything went ok.
        !           201:  */
        !           202: {
        !           203:     struct txtWin *newWin;     /* Text package specific information */
        !           204:     XWindowAttributes winInfo; /* Window information                */
        !           205:     int index;
        !           206:     XGCValues gc_val;
        !           207:     
        !           208:     if (textWindows == (XAssocTable *) 0) {
        !           209:        textWindows = XCreateAssocTable(32);
        !           210:        if (textWindows == (XAssocTable *) 0) return(0);
        !           211:     }
        !           212:     if (XGetWindowAttributes(display, txtWin, &winInfo) == 0) return 0;
        !           213: 
        !           214:     if (ScrollOption == NOOPTION) {
        !           215:        /* Read to see if the user wants jump scrolling or not */
        !           216:        if (XGetDefault(display, program, "JumpScroll")) {
        !           217:            ScrollOption = JUMPSCROLL;
        !           218:        } else {
        !           219:            ScrollOption = NORMSCROLL;
        !           220:        }
        !           221:     }
        !           222: 
        !           223:     /* Initialize local structure */
        !           224:     newWin = alloc(struct txtWin);
        !           225: 
        !           226:     /* Initialize arrow pixmap */
        !           227:     newWin->arrowMap = XCreatePixmapFromBitmapData(display, txtWin,
        !           228:                                                   arrow_bits,
        !           229:                                                   arrow_width, arrow_height,
        !           230:                                                   cur, bg,
        !           231:                                                   DisplayPlanes(display, 0));
        !           232: 
        !           233:     newWin->bufAlloc = INITBUFSIZE;
        !           234:     newWin->bufSpot = 0;
        !           235:     newWin->mainBuffer = numalloc(short, INITBUFSIZE);
        !           236: 
        !           237:     newWin->numLines = 1;
        !           238:     newWin->allocLines = INITLINES;
        !           239:     newWin->txtBuffer = numalloc(struct txtLine *, INITLINES);
        !           240:     for (index = 0;  index < INITLINES;  index++) {
        !           241:        newWin->txtBuffer[index] = alloc(struct txtLine);
        !           242:        InitLine(newWin->txtBuffer[index]);
        !           243:     }
        !           244: 
        !           245:     /* Window display information */
        !           246:     newWin->mainWindow = txtWin;
        !           247:     newWin->w = winInfo.width;
        !           248:     newWin->h = winInfo.height;
        !           249:     newWin->startLine = 0;
        !           250:     newWin->endLine = 0;
        !           251:     newWin->bottomSpace = winInfo.height
        !           252:       - YPADDING - mainFont->ascent - mainFont->descent - INTERLINE;
        !           253:     newWin->flagWord = 0;
        !           254:     newWin->bgPix = bg;
        !           255:     newWin->fgPix = fg;
        !           256: 
        !           257:     /* Scroll Bar Creation */
        !           258:     newWin->scrollBar = XCreateSimpleWindow(display, txtWin,
        !           259:                                      winInfo.width - BARSIZE,
        !           260:                                      0, BARSIZE - (2*BARBORDER),
        !           261:                                      winInfo.height - (2*BARBORDER),
        !           262:                                      BARBORDER, 
        !           263:                                      fg, bg);
        !           264:     XSelectInput(display, newWin->scrollBar, ExposureMask|ButtonReleaseMask);
        !           265:     XMapRaised(display, newWin->scrollBar);
        !           266: 
        !           267:     /* Font and Color Initialization */
        !           268:     newWin->theFonts[0] = *mainFont;
        !           269:     newWin->theColors[0] = fg;
        !           270:     gc_val.function = GXcopy;
        !           271:     gc_val.plane_mask = AllPlanes;
        !           272:     gc_val.foreground = fg;
        !           273:     gc_val.background = bg;
        !           274:     gc_val.graphics_exposures = 1;
        !           275:     gc_val.font = mainFont->fid;
        !           276:     gc_val.line_width = 1;
        !           277:     gc_val.line_style = LineSolid;
        !           278: 
        !           279:     newWin->fontGC[0] = XCreateGC(display, txtWin,
        !           280:                                  GCFunction | GCPlaneMask |
        !           281:                                  GCForeground | GCBackground |
        !           282:                                  GCGraphicsExposures | GCFont,
        !           283:                                  &gc_val);
        !           284: 
        !           285:     gc_val.foreground = cur;
        !           286:     newWin->CursorGC = XCreateGC(display, txtWin,
        !           287:                                 GCFunction | GCPlaneMask |
        !           288:                                  GCForeground | GCBackground |
        !           289:                                  GCLineStyle | GCLineWidth,
        !           290:                                  &gc_val);
        !           291: 
        !           292:     gc_val.foreground = bg;
        !           293:     newWin->bgGC = XCreateGC(display, txtWin,
        !           294:                                  GCFunction | GCPlaneMask |
        !           295:                                  GCForeground | GCBackground |
        !           296:                                  GCGraphicsExposures | GCFont,
        !           297:                                  &gc_val);
        !           298: 
        !           299: 
        !           300:     for (index = 1;  index < MAXFONTS;  index++) {
        !           301:        newWin->theFonts[index].fid = 0;
        !           302:        newWin->fontGC[index] = 0;
        !           303:     }
        !           304: 
        !           305:     
        !           306:     /* Initialize size of first line */
        !           307:     newWin->txtBuffer[0]->lineHeight = newWin->theFonts[0].ascent +
        !           308:        newWin->theFonts[0].descent;
        !           309:     newWin->txtBuffer[0]->lineText = 0;
        !           310: 
        !           311:     /* ExposeCopy array initialization */
        !           312:     newWin->exposeSize = 0;
        !           313:     newWin->exposeAlloc = INITEXPARY;
        !           314:     newWin->exposeAry = numalloc(struct expEvent *, INITEXPARY);
        !           315:     for (index = 0;  index < newWin->exposeAlloc;  index++)
        !           316:       newWin->exposeAry[index] = alloc(struct expEvent);
        !           317:     /* Put plus infinity in last slot for sorting purposes */
        !           318:     newWin->exposeAry[0]->lineIndex = MAXINT;
        !           319: 
        !           320:     /* Drawing Position Information */
        !           321:     newWin->curLine = 0;
        !           322:     newWin->curX = 0;
        !           323:     newWin->curY = YPADDING + mainFont->ascent + mainFont->descent;
        !           324: 
        !           325:     /* Attach it to both windows */
        !           326:     XMakeAssoc(display, textWindows, (XID) txtWin, (caddr_t) newWin);
        !           327:     XMakeAssoc(display, textWindows, (XID) newWin->scrollBar, (caddr_t) newWin);
        !           328:     return 1;
        !           329: }
        !           330: 
        !           331: 
        !           332: int TxtRelease(display, w)
        !           333: Display *display;
        !           334: Window w;                      /* Window to release */
        !           335: /*
        !           336:  * This routine releases all resources associated with the
        !           337:  * specified window which are consumed by the text
        !           338:  * window package. This includes the entire text buffer,  line start
        !           339:  * array,  and the scroll bar window.  However,  the window
        !           340:  * itself is NOT destroyed.  The routine will return zero if
        !           341:  * the window is not owned by the text window package.
        !           342:  */
        !           343: {
        !           344:     struct txtWin *textInfo;
        !           345:     int index;
        !           346: 
        !           347:     if ((textInfo = (struct txtWin *) XLookUpAssoc(display,
        !           348:                                                 textWindows, (XID) w)) == 0)
        !           349:       return 0;
        !           350: 
        !           351:     for (index = 0; index < MAXFONTS; index++)
        !           352:        if (textInfo->fontGC[index] != 0)
        !           353:            XFreeGC(display, textInfo->fontGC[index]);
        !           354: 
        !           355:     free((Generic) textInfo->mainBuffer);
        !           356:     for (index = 0;  index < textInfo->numLines;  index++) {
        !           357:        free((Generic) textInfo->txtBuffer[index]);
        !           358:     }
        !           359:     free((Generic) textInfo->txtBuffer);
        !           360:     XDestroyWindow(display, textInfo->scrollBar);
        !           361:     for (index = 0;  index < textInfo->exposeSize;  index++) {
        !           362:        free((Generic) textInfo->exposeAry[index]);
        !           363:     }
        !           364:     free((Generic) textInfo->exposeAry);
        !           365:     XDeleteAssoc(display, textWindows, (XID) w);
        !           366:     free((Generic) textInfo);
        !           367:     return 1;
        !           368: }
        !           369: 
        !           370: 
        !           371: 
        !           372: static int RecompBuffer(textInfo)
        !           373: struct txtWin *textInfo;       /* Text window information */
        !           374: /*
        !           375:  * This routine recomputes all line breaks in a buffer after
        !           376:  * a change in window size or font.  This is done by throwing
        !           377:  * away the old line start array and recomputing it.  Although
        !           378:  * a lot of this work is also done elsewhere,  it has been included
        !           379:  * inline here for efficiency.
        !           380:  */
        !           381: {
        !           382:     int startPos, endSize, linenum;
        !           383:     register int index, chsize, curfont;
        !           384:     register short *bufptr;
        !           385:     register XFontStruct *fontptr;
        !           386:     register struct txtLine *lineptr;
        !           387:     char theChar;
        !           388: 
        !           389:     /* Record the old position so we can come back to it */
        !           390:     for (startPos = textInfo->txtBuffer[textInfo->startLine]->lineText;
        !           391:         (startPos > 0) && (textInfo->mainBuffer[startPos] != '\n');
        !           392:         startPos--)
        !           393:       /* null loop body */;
        !           394:     
        !           395:     /* Clear out the old line start array */
        !           396:     for (index = 0;  index < textInfo->numLines;  index++) {
        !           397:        InitLine(textInfo->txtBuffer[index]);
        !           398:     }
        !           399: 
        !           400:     /* Initialize first line */
        !           401:     textInfo->txtBuffer[0]->lineHeight =
        !           402:        textInfo->theFonts[0].ascent + textInfo->theFonts[0].descent;
        !           403:     textInfo->txtBuffer[0]->lineText = 0;
        !           404: 
        !           405:     /* Process the text back into lines */
        !           406:     endSize = textInfo->w - BARSIZE - WRAPINDSIZE;
        !           407:     bufptr = textInfo->mainBuffer;
        !           408:     lineptr = textInfo->txtBuffer[0];
        !           409:     linenum = 0;
        !           410:     fontptr = &(textInfo->theFonts[0]);
        !           411:     curfont = 0;
        !           412:     for (index = 0;  index < textInfo->bufSpot;  index++) {
        !           413:        theChar = bufptr[index] & CHARMASK;
        !           414:        
        !           415:        if ((bufptr[index] & FONTMASK) != curfont) {
        !           416:            int newFontNum, heightDiff;
        !           417: 
        !           418:            /* Switch fonts */
        !           419:            newFontNum = (bufptr[index] & FONTMASK) >> FONTSHIFT;
        !           420:            if (textInfo->theFonts[newFontNum].fid != 0) {
        !           421:                /* Valid font */
        !           422:                curfont = bufptr[index] & FONTMASK;
        !           423:                fontptr = &(textInfo->theFonts[newFontNum]);
        !           424:                heightDiff = (fontptr->ascent + fontptr->descent) -
        !           425:                    lineptr->lineHeight;
        !           426:                if (heightDiff < 0) heightDiff = 0;
        !           427:                lineptr->lineHeight += heightDiff;
        !           428:            }
        !           429:        }
        !           430:        if (theChar == '\n') {
        !           431:            /* Handle new line */
        !           432:            if (linenum >= textInfo->allocLines-1)
        !           433:              /* Expand number of lines */
        !           434:              ExpandLines(textInfo);
        !           435:            linenum++;
        !           436:            lineptr = textInfo->txtBuffer[linenum];
        !           437:            /* Initialize next line */
        !           438:            lineptr->lineHeight = fontptr->ascent + fontptr->descent;
        !           439:            lineptr->lineText = index+1;
        !           440:            /* Check to see if its the starting line */
        !           441:            if (index == startPos) textInfo->startLine = linenum;
        !           442:        } else {
        !           443:            /* Handle normal character */
        !           444:            chsize = CharSize(textInfo, linenum, index);
        !           445:            if (lineptr->lineWidth + chsize > endSize) {
        !           446:                /* Handle line wrap */
        !           447:                lineptr->lineFlags |= WRAPFLAG;
        !           448:                if (linenum >= textInfo->allocLines-1)
        !           449:                  /* Expand number of lines */
        !           450:                  ExpandLines(textInfo);
        !           451:                linenum++;
        !           452:                lineptr = textInfo->txtBuffer[linenum];
        !           453:                /* Initialize next line */
        !           454:                lineptr->lineHeight = fontptr->ascent + fontptr->descent;
        !           455:                lineptr->lineText = index;
        !           456:                lineptr->lineLength = 1;
        !           457:                lineptr->lineWidth += chsize;
        !           458:            } else {
        !           459:                /* Handle normal addition of character */
        !           460:                lineptr->lineLength += 1;
        !           461:                lineptr->lineWidth += chsize;
        !           462:            }
        !           463:        }
        !           464:     }
        !           465:     /* We now have a valid line array.  Let's clean up some other fields. */
        !           466:     textInfo->numLines = linenum+1;
        !           467:     if (startPos == 0) {
        !           468:        textInfo->startLine = 0;
        !           469:     }
        !           470:     textInfo->endLine = FindEndLine(textInfo, &(textInfo->bottomSpace));
        !           471:     textInfo->curLine = linenum;
        !           472:     /* Check to see if we are at the bottom */
        !           473:     if (textInfo->endLine >= textInfo->numLines-1) {
        !           474:        textInfo->curY = textInfo->h - textInfo->bottomSpace -
        !           475:          lineptr->lineHeight;
        !           476:        textInfo->flagWord &= (~NOTATBOTTOM);
        !           477:     } else {
        !           478:        textInfo->flagWord |= NOTATBOTTOM;
        !           479:     }
        !           480:     return 1;
        !           481: }
        !           482: 
        !           483: 
        !           484: 
        !           485: 
        !           486: int TxtAddFont(display, textWin, fontNumber, newFont, newColor)
        !           487: Display *display;
        !           488: Window textWin;                        /* Scrollable text window  */
        !           489: int fontNumber;                        /* Place to add font (0-7) */
        !           490: XFontStruct *newFont;          /* Font to add             */
        !           491: int newColor;                  /* Color of font           */
        !           492: /*
        !           493:  * This routine loads a new font so that it can be used in a previously
        !           494:  * created text window.  There are eight font slots numbered 0 through 7.
        !           495:  * If there is already a font in the specified slot,  it will be replaced
        !           496:  * and an automatic redraw of the window will take place.  See TxtWriteStr
        !           497:  * for details on using alternate fonts.  The color specifies the foreground
        !           498:  * color of the text.  The default foreground color is used if this
        !           499:  * parameter is TXT_NO_COLOR.  Returns a non-zero value if
        !           500:  * everything went well.
        !           501:  */
        !           502: {
        !           503:     struct txtWin *textInfo;
        !           504:     int redrawFlag;
        !           505:     XGCValues gc_val;
        !           506:     
        !           507:     if ((fontNumber < 0) || (fontNumber >= MAXFONTS)) return 0;
        !           508:     if ((textInfo = (struct txtWin *)
        !           509:         XLookUpAssoc(display, textWindows, (XID) textWin)) == 0)
        !           510:       return 0;
        !           511:     if (newColor == TXT_NO_COLOR) {
        !           512:        newColor = textInfo->fgPix;
        !           513:     }
        !           514: 
        !           515:     gc_val.font = newFont->fid;
        !           516:     gc_val.foreground = newColor;
        !           517:     gc_val.background = textInfo->bgPix;
        !           518:     gc_val.plane_mask = AllPlanes;
        !           519:     gc_val.graphics_exposures = 1;
        !           520:     gc_val.function = GXcopy;
        !           521:     
        !           522:     if (textInfo->fontGC[fontNumber] != 0)
        !           523:     {
        !           524:        XChangeGC(display, textInfo->fontGC[fontNumber],
        !           525:                  GCFont | GCForeground, &gc_val);
        !           526:     }
        !           527:     else
        !           528:        textInfo->fontGC[fontNumber] = XCreateGC(display, textWin,
        !           529:                                                 GCFont |
        !           530:                                                 GCForeground |
        !           531:                                                 GCBackground |
        !           532:                                                 GCFunction |
        !           533:                                                 GCPlaneMask |
        !           534:                                                 GCGraphicsExposures,
        !           535:                                                 &gc_val); 
        !           536: 
        !           537: 
        !           538:     redrawFlag = (textInfo->theFonts[fontNumber].fid != 0) &&
        !           539:       (((newFont) && (newFont->fid != textInfo->theFonts[fontNumber].fid)) ||
        !           540:        (newColor != textInfo->theColors[fontNumber]));
        !           541:     if (newFont) {
        !           542:        textInfo->theFonts[fontNumber] = *newFont;
        !           543:     }
        !           544:     textInfo->theColors[fontNumber] = newColor;
        !           545: 
        !           546:     if (redrawFlag) {
        !           547:        RecompBuffer(textInfo);
        !           548:        XClearWindow(display, textWin);
        !           549:        TxtRepaint(display, textWin);
        !           550:     }
        !           551:     return 1;
        !           552: }
        !           553: 
        !           554: 
        !           555: 
        !           556: int TxtWinP(display, w)
        !           557: Display *display;
        !           558: Window w;
        !           559: /*
        !           560:  * Returns a non-zero value if the window has been previously grabbed
        !           561:  * using TxtGrab and 0 if it has not.
        !           562:  */
        !           563: {
        !           564:     if (XLookUpAssoc(display, textWindows, (XID) w))
        !           565:       return(1);
        !           566:     else return(0);
        !           567: }
        !           568: 
        !           569: 
        !           570: 
        !           571: static int FindEndLine(textInfo, botSpace)
        !           572: struct txtWin *textInfo;
        !           573: int *botSpace;
        !           574: /*
        !           575:  * Given the starting line in 'textInfo->startLine',  this routine
        !           576:  * determines the index of the last line that can be drawn given the
        !           577:  * current size of the screen.  If there are not enough lines to
        !           578:  * fill the screen,  the index of the last line will be returned.
        !           579:  * The amount of empty bottom space is returned in 'botSpace'.
        !           580:  */
        !           581: {
        !           582:     int index, height, lineHeight;
        !           583: 
        !           584:     height = YPADDING;
        !           585:     index = textInfo->startLine;
        !           586:     while (index < textInfo->numLines) {
        !           587:        lineHeight = textInfo->txtBuffer[index]->lineHeight + INTERLINE;
        !           588:        if (height + lineHeight > textInfo->h) break;
        !           589:        height += lineHeight;
        !           590:        index++;
        !           591:     }
        !           592:     if (botSpace) {
        !           593:        *botSpace = textInfo->h - height;
        !           594:     }
        !           595:     return index - 1;
        !           596: }
        !           597: 
        !           598: 
        !           599: 
        !           600: static int UpdateScroll(display, textInfo)
        !           601: Display *display;
        !           602: struct txtWin *textInfo;       /* Text window information */
        !           603: /*
        !           604:  * This routine computes the current extent of the scroll bar
        !           605:  * indicator and repaints the bar with the correct information.
        !           606:  */
        !           607: {
        !           608:     int top, bottom;
        !           609: 
        !           610:     if (textInfo->numLines > 1) {
        !           611:        top = textInfo->startLine * (textInfo->h - 2*BARBORDER) /
        !           612:          (textInfo->numLines - 1);
        !           613:        bottom = textInfo->endLine * (textInfo->h - 2*BARBORDER) /
        !           614:          (textInfo->numLines - 1);
        !           615:     } else {
        !           616:        top = 0;
        !           617:        bottom = textInfo->h - (2*BARBORDER);
        !           618:     }
        !           619: 
        !           620:     /* Draw it - make sure there is a little padding */
        !           621:     if (top == 0) top++;
        !           622:     if (bottom == textInfo->h-(2*BARBORDER)) bottom--;
        !           623: 
        !           624:     XFillRectangle(display, textInfo->scrollBar,
        !           625:                   textInfo->bgGC, 
        !           626:                   0, 0, BARSIZE, top-1);
        !           627:     XFillRectangle(display, textInfo->scrollBar,
        !           628:                   DEFAULT_GC, top, BARSIZE - (2*BARBORDER) - 2,
        !           629:                   bottom - top);
        !           630:     XFillRectangle(display, textInfo->scrollBar, DEFAULT_GC,
        !           631:                   0, bottom+1, BARSIZE,
        !           632:                   textInfo->h - (2 * BARBORDER) - bottom);
        !           633: 
        !           634:     return 1;
        !           635: }
        !           636: 
        !           637: 
        !           638: 
        !           639: 
        !           640: int TxtClear(display, w)
        !           641: Display *display;
        !           642: Window w;
        !           643: /*
        !           644:  * This routine clears a scrollable text window.  It resets the current
        !           645:  * writing position to the upper left hand corner of the screen. 
        !           646:  * NOTE:  THIS ALSO CLEARS THE CONTENTS OF THE TEXT WINDOW BUFFER AND
        !           647:  * RESETS THE SCROLL BAR.  Returns 0 if the window is not a text window.
        !           648:  * This should be used *instead* of XClear.
        !           649:  */
        !           650: {
        !           651:     struct txtWin *textInfo;
        !           652:     int index;
        !           653: 
        !           654:     if ((textInfo = (struct txtWin *) XLookUpAssoc(display, textWindows, (XID) w)) == 0)
        !           655:       return 0;
        !           656: 
        !           657:     /* Zero out the arrays */
        !           658:     textInfo->bufSpot = 0;
        !           659:     for (index = 0;  index < textInfo->numLines;  index++) {
        !           660:        InitLine(textInfo->txtBuffer[index]);
        !           661:     }
        !           662:     textInfo->txtBuffer[0]->lineHeight =
        !           663:       textInfo->theFonts[textInfo->curFont].ascent +
        !           664:          textInfo->theFonts[textInfo->curFont].descent;
        !           665: 
        !           666:     textInfo->numLines = 1;
        !           667:     textInfo->startLine = 0;
        !           668:     textInfo->endLine = 0;
        !           669:     textInfo->curLine = 0;
        !           670:     textInfo->curX = 0;
        !           671:     textInfo->curY = YPADDING + textInfo->theFonts[textInfo->curFont].ascent 
        !           672:        + textInfo->theFonts[textInfo->curFont].descent;
        !           673: 
        !           674:     textInfo->bottomSpace = textInfo->h - YPADDING -
        !           675:       textInfo->theFonts[textInfo->curFont].ascent - INTERLINE -
        !           676:          textInfo->theFonts[textInfo->curFont].descent;
        !           677:     /* Actually clear the window */
        !           678:     XClearWindow(display, w);
        !           679: 
        !           680:     /* Draw the current cursor */
        !           681:     XFillRectangle(display, w, textInfo->CursorGC,
        !           682:                   XPADDING + CUROFFSET, textInfo->curY,
        !           683:                   CURSORWIDTH,
        !           684:                   textInfo->theFonts[textInfo->curFont].ascent +
        !           685:                   textInfo->theFonts[textInfo->curFont].descent);
        !           686: 
        !           687:     /* Update the scroll bar */
        !           688:     UpdateScroll(display, textInfo);
        !           689:     return 1;
        !           690: }
        !           691: 
        !           692: 
        !           693: static int WarpToBottom(display, textInfo)
        !           694: Display *display;
        !           695: struct txtWin *textInfo;       /* Text Information */
        !           696: /*
        !           697:  * This routine causes the specified text window to display its
        !           698:  * last screen of information.   It updates the scroll bar
        !           699:  * to the appropriate spot.  The implementation scans backward
        !           700:  * through the buffer to find an appropriate starting spot for
        !           701:  * the window.
        !           702:  */
        !           703: {
        !           704:     int index, height, lineHeight;
        !           705: 
        !           706:     index = textInfo->numLines-1;
        !           707:     height = 0;
        !           708:     while (index >= 0) {
        !           709:        lineHeight = textInfo->txtBuffer[index]->lineHeight + INTERLINE;
        !           710:        if (height + lineHeight > textInfo->h) break;
        !           711:        height += lineHeight;
        !           712:        index--;
        !           713:     }
        !           714:     textInfo->startLine = index + 1;
        !           715:     textInfo->endLine = FindEndLine(textInfo, &(textInfo->bottomSpace));
        !           716:     textInfo->curY = textInfo->h - textInfo->bottomSpace -
        !           717:       textInfo->txtBuffer[textInfo->endLine]->lineHeight;
        !           718:     XClearWindow(display, textInfo->mainWindow);
        !           719:     TxtRepaint(display, textInfo->mainWindow);
        !           720:     return 1;
        !           721: }
        !           722: 
        !           723: 
        !           724: 
        !           725: static int UpdateExposures(display, textInfo)
        !           726: Display *display;
        !           727: struct txtWin *textInfo;       /* Text window information */
        !           728: /*
        !           729:  * Before a new scrolling action occurs,  the text window package
        !           730:  * must handle all COPYEXPOSE events generated by the last scrolling
        !           731:  * action.  This routine is called to do this.  Foreign events (those
        !           732:  * not handled by TxtFilter) are queued up and replaced on the queue
        !           733:  * after the processing of the exposure events is complete.
        !           734:  */
        !           735: {
        !           736: #if 0
        !           737:     XEvent foreignQueue[MAXFOREIGN];
        !           738:     int index, lastItem = 0;
        !           739: 
        !           740:     while (textInfo->flagWord & COPYEXPOSE) {
        !           741:        XNextEvent(display, &(foreignQueue[lastItem]));
        !           742:        if (!TxtFilter(display, &(foreignQueue[lastItem])))
        !           743:          lastItem++;
        !           744:        if (lastItem >= MAXFOREIGN) {
        !           745:            printf("Too many foreign events to queue!\n");
        !           746:            textInfo->flagWord &= (~COPYEXPOSE);
        !           747:        }
        !           748:     }
        !           749:     for (index = 0;  index < lastItem;  index++) {
        !           750:        XPutBackEvent(display, &(foreignQueue[index]));
        !           751:     }
        !           752: #endif
        !           753:     return 1;
        !           754: }
        !           755: 
        !           756: 
        !           757: static int ScrollDown(display,textInfo)
        !           758: Display *display;
        !           759: struct txtWin *textInfo;       /* Text window information */
        !           760: /*
        !           761:  * This routine scrolls the indicated text window down by one
        !           762:  * line.  The line below the current line must exist.  The window
        !           763:  * is scrolled so that the line below the last line is fully
        !           764:  * displayed.  This may cause many lines to scroll off the top.
        !           765:  * Scrolling is done using XCopyArea.  The exposure events should
        !           766:  * be caught using ExposeCopy.
        !           767:  */
        !           768: {
        !           769:     int lineSum, index, targetSpace, freeSpace, updateFlag;
        !           770: 
        !           771:     lineSum = 0;
        !           772:     if (textInfo->endLine + 1 >= textInfo->numLines) return 0;
        !           773:     targetSpace = textInfo->txtBuffer[textInfo->endLine+1]->lineHeight +
        !           774:       INTERLINE;
        !           775:     if (textInfo->bottomSpace < targetSpace) {
        !           776:        index = textInfo->startLine;
        !           777:        while (index < textInfo->endLine) {
        !           778:            lineSum += (textInfo->txtBuffer[index]->lineHeight + INTERLINE);
        !           779:            if (textInfo->bottomSpace + lineSum >= targetSpace) break;
        !           780:            index++;
        !           781:        }
        !           782: 
        !           783:        /* Must move upward by 'lineSum' pixels */
        !           784:        XCopyArea(display, textInfo->mainWindow, textInfo->mainWindow,
        !           785:                  DEFAULT_GC, 0, lineSum,
        !           786:                  textInfo->w - BARSIZE, textInfo->h,
        !           787:                  0, 0);
        !           788: 
        !           789:        textInfo->flagWord |= COPYEXPOSE;
        !           790:        /* Repair the damage to the structures */
        !           791:        textInfo->startLine = index + 1;
        !           792:        updateFlag = 1;
        !           793:     } else {
        !           794:        updateFlag = 0;
        !           795:     }
        !           796:     /* More lines might be able to fit.  Let's check. */
        !           797:     freeSpace = textInfo->bottomSpace + lineSum - targetSpace;
        !           798:     index = textInfo->endLine + 1;
        !           799:     while (index < textInfo->numLines-1) {
        !           800:        if (freeSpace - textInfo->txtBuffer[index+1]->lineHeight - INTERLINE < 0)
        !           801:          break;
        !           802:        freeSpace -= (textInfo->txtBuffer[index+1]->lineHeight + INTERLINE);
        !           803:        index++;
        !           804:     }
        !           805:     textInfo->endLine = index;
        !           806:     textInfo->bottomSpace = freeSpace;
        !           807:     if (updateFlag) {
        !           808:        UpdateExposures(display, textInfo);
        !           809:     }
        !           810:     UpdateScroll(display, textInfo);
        !           811:     return 1;
        !           812: }
        !           813: 
        !           814: 
        !           815: 
        !           816: 
        !           817: static int ExpandLines(textInfo)
        !           818: struct txtWin *textInfo;       /* Text Information */
        !           819: /*
        !           820:  * This routine allocates and initializes additional space in
        !           821:  * the line start array (txtBuffer).  The new space
        !           822:  * is allocated using realloc.  The expansion factor is a percentage
        !           823:  * given by EXPANDPERCENT.
        !           824:  */
        !           825: {
        !           826:     int newSize, index;
        !           827: 
        !           828:     newSize = textInfo->allocLines;
        !           829:     newSize += (newSize * EXPANDPERCENT) / 100;
        !           830: 
        !           831:     textInfo->txtBuffer = (struct txtLine **)
        !           832:       realloc((char *) textInfo->txtBuffer,
        !           833:              (unsigned) (newSize * sizeof(struct txtLine *)));
        !           834:     for (index = textInfo->allocLines;  index < newSize;  index++) {
        !           835:        textInfo->txtBuffer[index] = alloc(struct txtLine);
        !           836:        InitLine(textInfo->txtBuffer[index]);
        !           837:     }
        !           838:     textInfo->allocLines = newSize;
        !           839:     return 1;
        !           840: }
        !           841: 
        !           842: static int ExpandBuffer(textInfo)
        !           843: struct txtWin *textInfo;       /* Text information */
        !           844: /*
        !           845:  * Expands the basic character buffer using realloc.  The expansion
        !           846:  * factor is a percentage given by EXPANDPERCENT.
        !           847:  */
        !           848: {
        !           849:     int newSize;
        !           850: 
        !           851:     newSize = textInfo->bufAlloc + (textInfo->bufAlloc * EXPANDPERCENT) / 100;
        !           852:     textInfo->mainBuffer = (short *)
        !           853:       realloc((char *) textInfo->mainBuffer, (unsigned) newSize * sizeof(short));
        !           854:     textInfo->bufAlloc = newSize;
        !           855:     return 1;
        !           856: }
        !           857: 
        !           858: 
        !           859: 
        !           860: static int HandleNewLine(display, textInfo, flagWord)
        !           861: Display *display;
        !           862: struct txtWin *textInfo;       /* Text Information            */
        !           863: int flagWord;                  /* DODISP or NONEWLINE or both */
        !           864: /*
        !           865:  * This routine initializes the next line for drawing by setting
        !           866:  * its height to the current font height,  scrolls the screen down
        !           867:  * one line,  and updates the current drawing position to the
        !           868:  * left edge of the newly cleared line.  If DODISP is specified,
        !           869:  * the screen will be updated (otherwise not).  If NONEWLINE is
        !           870:  * specified,  no newline character will be added to the text buffer
        !           871:  * (this is for line wrap).
        !           872:  */
        !           873: {
        !           874:     struct txtLine *curLine, *nextLine;
        !           875: 
        !           876:     /* Check to see if a new line must be allocated */
        !           877:     if (textInfo->curLine >= textInfo->allocLines-1)
        !           878:       /* Expand the number of lines */
        !           879:       ExpandLines(textInfo);
        !           880:     textInfo->numLines += 1;
        !           881: 
        !           882:     /* Then we initialize the next line */
        !           883:     nextLine = textInfo->txtBuffer[textInfo->numLines-1];
        !           884:     nextLine->lineHeight =
        !           885:        textInfo->theFonts[textInfo->curFont].ascent +
        !           886:            textInfo->theFonts[textInfo->curFont].descent;
        !           887: 
        !           888:     curLine = textInfo->txtBuffer[textInfo->curLine];
        !           889:     if (flagWord & DODISP) {
        !           890:        /* Scroll down a line if required */
        !           891:        if ((textInfo->curY + curLine->lineHeight +
        !           892:             nextLine->lineHeight + (INTERLINE * 2)) > textInfo->h)
        !           893:          {
        !           894:              ScrollDown(display, textInfo);
        !           895:          }
        !           896:        else
        !           897:          {
        !           898:              /* Update the bottom space appropriately */
        !           899:              textInfo->bottomSpace -= (nextLine->lineHeight + INTERLINE);
        !           900:              textInfo->endLine += 1;
        !           901:          }
        !           902:        /* Update drawing position */
        !           903:        textInfo->curY = textInfo->h -
        !           904:          (textInfo->bottomSpace  + nextLine->lineHeight);
        !           905:     }
        !           906: 
        !           907:     /* Move down a line */
        !           908:     textInfo->curLine += 1;
        !           909:     if (!(flagWord & NONEWLINE)) {
        !           910:        /* Append end-of-line to text buffer */
        !           911:        if (textInfo->bufSpot >= textInfo->bufAlloc) {
        !           912:            /* Allocate more space in main text buffer */
        !           913:            ExpandBuffer(textInfo);
        !           914:        }
        !           915:        textInfo->mainBuffer[(textInfo->bufSpot)++] =
        !           916:          (textInfo->curFont << FONTSHIFT) | '\n';
        !           917:     }
        !           918:     nextLine->lineText = textInfo->bufSpot;
        !           919:     textInfo->curX = 0;
        !           920:     return 1;
        !           921: }
        !           922: 
        !           923: 
        !           924: 
        !           925: static int CharSize(textInfo, lineNum, charNum)
        !           926: struct txtWin *textInfo;       /* Current Text Information */
        !           927: int lineNum;                   /* Line in buffer           */
        !           928: int charNum;                   /* Character in line        */
        !           929: /*
        !           930:  * This routine determines the size of the specified character.
        !           931:  * It takes in account the font of the character and whether its
        !           932:  * fixed or variable.  The size includes INTERSPACE spacing between
        !           933:  * the characters.
        !           934:  */
        !           935: {
        !           936:     register XFontStruct *charFont;
        !           937:     register short *theLine;
        !           938:     register short theChar;
        !           939: 
        !           940:     theLine = &(textInfo->mainBuffer[textInfo->txtBuffer[lineNum]->lineText]);
        !           941:     theChar = theLine[charNum] & CHARMASK;
        !           942:     charFont = &(textInfo->theFonts[(theChar & FONTMASK) >> FONTSHIFT]);
        !           943:     if (theChar <= charFont->min_char_or_byte2 ||
        !           944:        theChar >= charFont->max_char_or_byte2 ||
        !           945:        charFont->per_char == 0)
        !           946:        return  charFont->max_bounds.width + 1;
        !           947:     else
        !           948:        return charFont->per_char[theChar].width + 1;
        !           949: }
        !           950: 
        !           951: 
        !           952: 
        !           953: 
        !           954: 
        !           955: static int HandleBackspace(display, textInfo, flagWord)
        !           956: Display *display;
        !           957: struct txtWin *textInfo;       /* Text Information  */
        !           958: int flagWord;                  /* DODISP or nothing */
        !           959: /*
        !           960:  * This routine handles a backspace found in the input stream.  The
        !           961:  * character before the current writing position will be erased and
        !           962:  * the drawing position will move back one character.  If the writing
        !           963:  * position is at the left margin,  the drawing position will move
        !           964:  * up to the previous line.  If it is a line that has been wrapped,
        !           965:  * the character at the end of the previous line will be erased.
        !           966:  */
        !           967: {
        !           968:     struct txtLine *thisLine, *prevLine;
        !           969:     int chSize;
        !           970: 
        !           971:     thisLine = textInfo->txtBuffer[textInfo->curLine];
        !           972:     /* First,  determine whether we need to go back a line */
        !           973:     if (thisLine->lineLength == 0) {
        !           974:        /* Bleep if at top of buffer */
        !           975:        if (textInfo->curLine == 0) {
        !           976:            XBell(display, 50);
        !           977:            return 0;
        !           978:        }
        !           979: 
        !           980:        /* See if we have to scroll in the other direction */
        !           981:        if ((flagWord & DODISP) && (textInfo->curY <= YPADDING)) {
        !           982:            /* This will display the last lines of the buffer */
        !           983:            WarpToBottom(display, textInfo);
        !           984:        }
        !           985: 
        !           986:        /* Set drawing position at end of previous line */
        !           987:        textInfo->curLine -= 1;
        !           988:        prevLine = textInfo->txtBuffer[textInfo->curLine];
        !           989:        textInfo->numLines -= 1;
        !           990:        if (flagWord & DODISP) {
        !           991:            textInfo->curY -= (prevLine->lineHeight + INTERLINE);
        !           992:            textInfo->bottomSpace += (thisLine->lineHeight + INTERLINE);
        !           993:            textInfo->endLine -= 1;
        !           994:        }
        !           995: 
        !           996:        /* We are unlinewrapping if the previous line has flag set */
        !           997:        if (prevLine->lineFlags & WRAPFLAG) {
        !           998:            /* Get rid of line wrap indicator */
        !           999:            if (flagWord & DODISP) {
        !          1000:                XFillRectangle(display, textInfo->mainWindow,
        !          1001:                               textInfo->bgGC,
        !          1002:                               textInfo->w - BARSIZE - WRAPINDSIZE,
        !          1003:                               textInfo->curY,  WRAPINDSIZE,
        !          1004:                               prevLine->lineHeight);
        !          1005:            }
        !          1006:            prevLine->lineFlags &= (~WRAPFLAG);
        !          1007:            /* Call recursively to wipe out the ending character */
        !          1008:            HandleBackspace(display, textInfo, flagWord);
        !          1009:        } else {
        !          1010:            /* Delete the end-of-line in the primary buffer */
        !          1011:            textInfo->bufSpot -= 1;
        !          1012:        }
        !          1013:     } else {
        !          1014:        /* Normal deletion of character */
        !          1015:        chSize =
        !          1016:          CharSize(textInfo, textInfo->curLine,
        !          1017:                   textInfo->txtBuffer[textInfo->curLine]->lineLength - 1);
        !          1018:        /* Move back appropriate amount and wipe it out */
        !          1019:        thisLine->lineWidth -= chSize;
        !          1020:        if (flagWord & DODISP) {
        !          1021:            XFillRectangle(display, textInfo->mainWindow,
        !          1022:                           textInfo->bgGC,
        !          1023:                           thisLine->lineWidth, textInfo->curY,
        !          1024:                           chSize, thisLine->lineHeight);
        !          1025:        }
        !          1026:        /* Delete from buffer */
        !          1027:        textInfo->txtBuffer[textInfo->curLine]->lineLength -= 1;
        !          1028:        textInfo->bufSpot -= 1;
        !          1029:     }
        !          1030:     return 1;
        !          1031: }
        !          1032: 
        !          1033: 
        !          1034: 
        !          1035: static int DrawLineWrap(display, win, x, y, h, col)
        !          1036: Display *display;
        !          1037: Window win;                    /* What window to draw it in     */
        !          1038: int x, y;                      /* Position of upper left corner */
        !          1039: int h;                         /* Height of indicator           */
        !          1040: int col;                       /* Color of indicator            */
        !          1041: /*
        !          1042:  * This routine draws a line wrap indicator at the end of a line.
        !          1043:  * Visually,  it is an arrow of the specified height directly against
        !          1044:  * the scroll bar border.  The bitmap used for the arrow is stored
        !          1045:  * in 'arrowMap' with size 'arrow_width' and 'arrow_height'.
        !          1046:  */
        !          1047: {
        !          1048:     struct txtWin *textInfo;
        !          1049: 
        !          1050:     textInfo = (struct txtWin *)XLookUpAssoc(display, textWindows,
        !          1051:                                             (XID) win);
        !          1052: 
        !          1053:     /* First,  draw the arrow */
        !          1054:     XCopyArea(display, textInfo->arrowMap, textInfo->mainWindow,
        !          1055:               textInfo->CursorGC,
        !          1056:               0, 0, arrow_width, arrow_height,
        !          1057:               x, y + h - arrow_height, 1);
        !          1058: 
        !          1059:     /* Then draw the stem */
        !          1060:     XDrawLine(display, textInfo->mainWindow, textInfo->CursorGC,
        !          1061:              x + STEMOFFSET, y,
        !          1062:              x + STEMOFFSET, y + h - arrow_height);
        !          1063:     return 1;
        !          1064: }
        !          1065: 
        !          1066: 
        !          1067: 
        !          1068: 
        !          1069: static int DrawLine(display, textInfo, lineIndex, ypos)
        !          1070: Display *display;
        !          1071: struct txtWin *textInfo;       /* Text window information   */
        !          1072: int lineIndex;                 /* Index of line to draw     */
        !          1073: int ypos;                      /* Y position for line       */
        !          1074: /*
        !          1075:  * This routine destructively draws the indicated line in the
        !          1076:  * indicated window at the indicated position.  It does not
        !          1077:  * clear to end of line however.  It draws a line wrap indicator
        !          1078:  * if needed but does not draw a cursor.
        !          1079:  */
        !          1080: {
        !          1081:     int index, startPos, curFont, theColor, curX, saveX, fontIndex;
        !          1082:     struct txtLine *someLine;
        !          1083:     char lineBuffer[BUFSIZE], *glyph;
        !          1084:     short *linePointer;
        !          1085:     XFontStruct *theFont;
        !          1086:     XGCValues gc;
        !          1087: 
        !          1088:     /* First,  we draw the text */
        !          1089:     index = 0;
        !          1090:     curX = XPADDING;
        !          1091:     someLine = textInfo->txtBuffer[lineIndex];
        !          1092:     linePointer = &(textInfo->mainBuffer[someLine->lineText]);
        !          1093:     while (index < someLine->lineLength) {
        !          1094:        startPos = index;
        !          1095:        saveX = curX;
        !          1096:        curFont = linePointer[index] & FONTMASK;
        !          1097:        fontIndex = curFont >> FONTSHIFT;
        !          1098:        theFont = &(textInfo->theFonts[fontIndex]);
        !          1099:        theColor = textInfo->theColors[fontIndex];
        !          1100:        glyph = &(lineBuffer[0]);
        !          1101:        while ((index < someLine->lineLength) &&
        !          1102:               ((linePointer[index] & FONTMASK) == curFont))
        !          1103:        {
        !          1104:            *glyph = linePointer[index] & CHARMASK;
        !          1105:            index++;
        !          1106:            curX += CharSize(textInfo, lineIndex, index);
        !          1107:            glyph++;
        !          1108:        }
        !          1109:        
        !          1110:        /* Flush out the glyphs */
        !          1111:        XFillRectangle(display, textInfo->mainWindow,
        !          1112:                       textInfo->bgGC,
        !          1113:                       saveX, ypos,
        !          1114:                   textInfo->w - BARSIZE,
        !          1115:                   someLine->lineHeight + YPADDING + INTERLINE);
        !          1116: 
        !          1117:        XDrawString(display, textInfo->mainWindow,
        !          1118:                    textInfo->fontGC[fontIndex],
        !          1119:                    saveX, ypos,
        !          1120:                    lineBuffer, someLine->lineLength);
        !          1121:     }
        !          1122:     /* Then the line wrap indicator (if needed) */
        !          1123:     if (someLine->lineFlags & WRAPFLAG) {
        !          1124:        DrawLineWrap(display, textInfo->mainWindow,
        !          1125:                     textInfo->w - BARSIZE - WRAPINDSIZE,
        !          1126:                     ypos, someLine->lineHeight,
        !          1127:                     textInfo->fgPix);
        !          1128:     }
        !          1129:     return 1;
        !          1130: }
        !          1131: 
        !          1132: 
        !          1133: 
        !          1134: 
        !          1135: static int HandleNewFont(display, fontNum, textInfo, flagWord)
        !          1136: Display *display;
        !          1137: int fontNum;                   /* Font number       */
        !          1138: struct txtWin *textInfo;       /* Text information  */
        !          1139: int flagWord;                  /* DODISP or nothing */
        !          1140: /*
        !          1141:  * This routine handles a new font request.  These requests take
        !          1142:  * the form "^F<digit>".  The parsing is done in TxtWriteStr.
        !          1143:  * This routine is called only if the form is valid.  It may return
        !          1144:  * a failure (0 status) if the requested font is not loaded.
        !          1145:  * If the new font is larger than any of the current
        !          1146:  * fonts on the line,  it will change the line height and redisplay
        !          1147:  * the line.
        !          1148:  */
        !          1149: {
        !          1150:     struct txtLine *thisLine;
        !          1151:     int heightDiff, baseDiff, redrawFlag;
        !          1152: 
        !          1153:     if (textInfo->theFonts[fontNum].fid == 0) {
        !          1154:        return 0;
        !          1155:     } else {
        !          1156:        thisLine = textInfo->txtBuffer[textInfo->curLine];
        !          1157:        textInfo->curFont = fontNum;
        !          1158:        redrawFlag = 0;
        !          1159:        heightDiff = textInfo->theFonts[fontNum].ascent +
        !          1160:            textInfo->theFonts[fontNum].descent -
        !          1161:                thisLine->lineHeight;
        !          1162: 
        !          1163:        if (heightDiff > 0) {
        !          1164:            redrawFlag = 1;
        !          1165:        } else {
        !          1166:            heightDiff = 0;
        !          1167:        }
        !          1168: 
        !          1169:        if (redrawFlag) {
        !          1170:            if (flagWord & DODISP) {
        !          1171:                /* Clear current line */
        !          1172:                XFillRectangle(display, textInfo->mainWindow,
        !          1173:                               textInfo->bgGC,
        !          1174:                               0, textInfo->curY, textInfo->w,
        !          1175:                               thisLine->lineHeight);
        !          1176: 
        !          1177:                /* Check to see if it requires scrolling */
        !          1178:                if ((textInfo->curY + thisLine->lineHeight + heightDiff +
        !          1179:                     INTERLINE) > textInfo->h)
        !          1180:                  {
        !          1181:                      /* 
        !          1182:                       * General approach:  "unscroll" the last line up
        !          1183:                       * and then call ScrollDown to do the right thing.
        !          1184:                       */
        !          1185:                      textInfo->endLine -= 1;
        !          1186:                      textInfo->bottomSpace += thisLine->lineHeight +
        !          1187:                          INTERLINE;
        !          1188: 
        !          1189:                      XFillRectangle(display, textInfo->mainWindow,
        !          1190:                                     textInfo->bgGC,
        !          1191:                                     0, textInfo->h - textInfo->bottomSpace,
        !          1192:                                     textInfo->w, textInfo->bottomSpace);
        !          1193: 
        !          1194:                      thisLine->lineHeight += heightDiff;
        !          1195:                      ScrollDown(display, textInfo);
        !          1196:                      textInfo->curY = textInfo->h -
        !          1197:                        (textInfo->bottomSpace + INTERLINE +
        !          1198:                         thisLine->lineHeight);
        !          1199:                  }
        !          1200:                else 
        !          1201:                  {
        !          1202:                      /* Just update bottom space */
        !          1203:                      textInfo->bottomSpace -= heightDiff;
        !          1204:                      thisLine->lineHeight += heightDiff;
        !          1205:                  }
        !          1206:                /* Redraw the current line */
        !          1207:                DrawLine(display, textInfo, textInfo->curLine, textInfo->curY);
        !          1208:            } else {
        !          1209:                /* Just update line height */
        !          1210:                thisLine->lineHeight += heightDiff;
        !          1211:            }
        !          1212:        }
        !          1213:        return 1;
        !          1214:     }
        !          1215: }
        !          1216: 
        !          1217: 
        !          1218: 
        !          1219: int TxtWriteStr(display, w, str)
        !          1220: Display *display;
        !          1221: Window w;                      /* Text window            */
        !          1222: register char *str;            /* 0 terminated string */
        !          1223: /*
        !          1224:  * This routine writes a string to the specified text window.
        !          1225:  * The following notes apply:
        !          1226:  *   - Text is always appended to the end of the text buffer.
        !          1227:  *   - If the scroll bar is positioned such that the end of the
        !          1228:  *     text is not visible,  an automatic scroll to the bottom
        !          1229:  *     will be done before the appending of text.
        !          1230:  *   - Non-printable ASCII characters are not displayed.
        !          1231:  *   - The '\n' character causes the current text position to
        !          1232:  *     advance one line and start at the left.
        !          1233:  *   - Tabs are not supported.
        !          1234:  *   - Lines too long for the screen will be wrapped and a line wrap
        !          1235:  *     indication will be drawn.
        !          1236:  *   - Backspace clears the previous character.  It will do the right
        !          1237:  *     thing if asked to backspace past a wrapped line.
        !          1238:  *   - A new font can be chosen using the sequence '^F<digit>' where
        !          1239:  *     <digit> is 0-7.  The directive will be ignored if
        !          1240:  *     there is no font in the specified slot.
        !          1241:  * Returns 0 if something went wrong.  
        !          1242:  */
        !          1243: {
        !          1244:     register int fontIndex;
        !          1245:     register struct txtWin *textInfo;
        !          1246:     register struct txtLine *thisLine;
        !          1247: 
        !          1248:     if ((textInfo = (struct txtWin *) XLookUpAssoc(display, textWindows, (XID) w)) == 0)
        !          1249:       return 0;
        !          1250:     
        !          1251:     /* See if screen needs to be updated */
        !          1252:     if (textInfo->flagWord & SCREENWRONG) {
        !          1253:        TxtRepaint(display, textInfo->mainWindow);
        !          1254:     }
        !          1255: 
        !          1256:     /* See if we have to scroll down to the bottom */
        !          1257:     if (textInfo->flagWord & NOTATBOTTOM) {
        !          1258:        WarpToBottom(display, textInfo);
        !          1259:        textInfo->flagWord &= (~NOTATBOTTOM);
        !          1260:     }
        !          1261: 
        !          1262:     /* Undraw the current cursor */
        !          1263:     thisLine = textInfo->txtBuffer[textInfo->curLine];
        !          1264: 
        !          1265:     XFillRectangle(display, w, textInfo->bgGC,
        !          1266:            thisLine->lineWidth + CUROFFSET,
        !          1267:            textInfo->curY,
        !          1268:            CURSORWIDTH,
        !          1269:            thisLine->lineHeight);
        !          1270: 
        !          1271:     for ( /* str is ok */ ; (*str != 0) ; str++) {
        !          1272:        /* Check to see if we are waiting on a font */
        !          1273:        if (textInfo->flagWord & FONTNUMWAIT) {
        !          1274:            textInfo->flagWord &= (~FONTNUMWAIT);
        !          1275:            fontIndex = *str - '0';
        !          1276:            if ((fontIndex >= 0) && (fontIndex < MAXFONTS)) {
        !          1277:                /* Handle font -- go get next character */
        !          1278:                if (HandleNewFont(display, fontIndex, textInfo, DODISP))
        !          1279:                    continue;
        !          1280:            }
        !          1281:        }
        !          1282:        
        !          1283:        /* Inline code for handling normal character case */
        !          1284:        if ((*str >= LOWCHAR) && (*str <= HIGHCHAR)) {
        !          1285:            register XFontStruct *thisFont;
        !          1286:            register struct txtLine *thisLine;
        !          1287:            register int charWidth;
        !          1288:            int thisColor;
        !          1289: 
        !          1290:            /* Determine size of character */
        !          1291:            thisFont = &(textInfo->theFonts[textInfo->curFont]);
        !          1292:            thisColor = textInfo->theColors[textInfo->curFont];
        !          1293:            if (*str <= thisFont->min_char_or_byte2 ||
        !          1294:                *str >= thisFont->max_char_or_byte2 ||
        !          1295:                thisFont->per_char == 0)
        !          1296:                charWidth = thisFont->max_bounds.width + 1;
        !          1297:            else
        !          1298:                charWidth = thisFont->per_char[*str].width + 1;
        !          1299: 
        !          1300:            /* Check to see if line wrap is required */
        !          1301:            thisLine = textInfo->txtBuffer[textInfo->curLine];
        !          1302:            if (thisLine->lineWidth + charWidth >
        !          1303:                (textInfo->w-BARSIZE-WRAPINDSIZE))
        !          1304:              {
        !          1305:                  DrawLineWrap(display, textInfo->mainWindow,
        !          1306:                               textInfo->w-BARSIZE-WRAPINDSIZE,
        !          1307:                               textInfo->curY, thisLine->lineHeight,
        !          1308:                               textInfo->fgPix);
        !          1309:                  thisLine->lineFlags |= WRAPFLAG;
        !          1310:                  /* Handle the spacing problem the same way as a newline */
        !          1311:                  HandleNewLine(display, textInfo, DODISP | NONEWLINE);
        !          1312:                  thisLine = textInfo->txtBuffer[textInfo->curLine];
        !          1313:              }
        !          1314:            
        !          1315:            /* Ready to draw character */
        !          1316:            XDrawString(display, textInfo->mainWindow,
        !          1317:                        DEFAULT_GC, 
        !          1318:                        textInfo->curX += charWidth,
        !          1319:                        textInfo->curY + thisLine->lineHeight, 
        !          1320:                        str, 1);
        !          1321:            
        !          1322:            /* Append character onto main buffer */
        !          1323:            if (textInfo->bufSpot >= textInfo->bufAlloc)
        !          1324:              /* Make room for more characters */
        !          1325:              ExpandBuffer(textInfo);
        !          1326:            textInfo->mainBuffer[(textInfo->bufSpot)++] =
        !          1327:              (textInfo->curFont << FONTSHIFT) | (*str);
        !          1328:            
        !          1329:            /* Update the line start array */
        !          1330:            thisLine->lineLength += 1;
        !          1331:            thisLine->lineWidth += charWidth;
        !          1332:        } else if (*str == NEWLINE) {
        !          1333:            HandleNewLine(display, textInfo, DODISP);
        !          1334:        } else if (*str == NEWFONT) {
        !          1335:            /* Go into waiting for font number mode */
        !          1336:            textInfo->flagWord |= FONTNUMWAIT;
        !          1337:        } else if (*str == BACKSPACE) {
        !          1338:            HandleBackspace(display, textInfo, DODISP);
        !          1339:        } else {
        !          1340:            /* Ignore all others */
        !          1341:        }
        !          1342:     }
        !          1343:     /* Draw the cursor in its new position */
        !          1344:     thisLine = textInfo->txtBuffer[textInfo->curLine];
        !          1345: 
        !          1346:     XFillRectangle(display, w, textInfo->CursorGC,
        !          1347:            thisLine->lineWidth + CUROFFSET,
        !          1348:            textInfo->curY /* + thisLine->lineHeight */,
        !          1349:            CURSORWIDTH, thisLine->lineHeight);
        !          1350: 
        !          1351:     return 1;
        !          1352: }
        !          1353: 
        !          1354: 
        !          1355: 
        !          1356: int TxtJamStr(display, w, str)
        !          1357: Display *display;
        !          1358: Window w;                      /* Text window            */
        !          1359: register char *str;            /* NULL terminated string */
        !          1360: /*
        !          1361:  * This is the same as TxtWriteStr except the screen is NOT updated.
        !          1362:  * After a call to this routine,  TxtRepaint should be called to
        !          1363:  * update the screen.  This routine is meant to be used to load
        !          1364:  * a text buffer with information and then allow the user to
        !          1365:  * scroll through it at will.
        !          1366:  */
        !          1367: {
        !          1368:     register int fontIndex;
        !          1369:     register struct txtWin *textInfo;
        !          1370: 
        !          1371:     if ((textInfo = (struct txtWin *) XLookUpAssoc(display, textWindows, (XID) w)
        !          1372:         ) == 0)
        !          1373:       return 0;
        !          1374:     
        !          1375:     for ( /* str is ok */ ; (*str != 0) ; str++) {
        !          1376:        /* Check to see if we are waiting on a font */
        !          1377:        if (textInfo->flagWord & FONTNUMWAIT) {
        !          1378:            textInfo->flagWord &= (~FONTNUMWAIT);
        !          1379:            fontIndex = *str - '0';
        !          1380:            if ((fontIndex >= 0) && (fontIndex < MAXFONTS)) {
        !          1381:                if (HandleNewFont(display, fontIndex, textInfo, 0)) {
        !          1382:                    /* Handled font -- go get next character */
        !          1383:                    continue;
        !          1384:                }
        !          1385:            }
        !          1386:        }
        !          1387:        /* Inline code for handling normal character case */
        !          1388:        if ((*str >= LOWCHAR) && (*str <= HIGHCHAR)) {
        !          1389:            register XFontStruct *thisFont;
        !          1390:            register struct txtLine *thisLine;
        !          1391:            register int charWidth;
        !          1392:            
        !          1393:            /* Determine size of character */
        !          1394:            thisFont = &(textInfo->theFonts[textInfo->curFont]);
        !          1395: 
        !          1396:            if (*str <= thisFont->min_char_or_byte2 ||
        !          1397:                *str >= thisFont->max_char_or_byte2 ||
        !          1398:                thisFont->per_char == 0)
        !          1399:                charWidth = thisFont->max_bounds.width + 1;
        !          1400:            else
        !          1401:                charWidth = thisFont->per_char[*str].width + 1;
        !          1402: 
        !          1403:            /* Check to see if line wrap is required */
        !          1404:            thisLine = textInfo->txtBuffer[textInfo->curLine];
        !          1405:            if (thisLine->lineWidth + charWidth >
        !          1406:                (textInfo->w-BARSIZE-WRAPINDSIZE))
        !          1407:              {
        !          1408:                  thisLine->lineFlags |= WRAPFLAG;
        !          1409:                  /* Handle the spacing problem the same way as a newline */
        !          1410:                  HandleNewLine(display, textInfo, NONEWLINE);
        !          1411:                  thisLine = textInfo->txtBuffer[textInfo->curLine];
        !          1412:              }
        !          1413:            /* Append character onto main buffer */
        !          1414:            if (textInfo->bufSpot >= textInfo->bufAlloc)
        !          1415:              /* Make room for more characters */
        !          1416:              ExpandBuffer(textInfo);
        !          1417:            textInfo->mainBuffer[(textInfo->bufSpot)++] =
        !          1418:              (textInfo->curFont << FONTSHIFT) | (*str);
        !          1419:            
        !          1420:            /* Update the line start array */
        !          1421:            thisLine->lineLength += 1;
        !          1422:            thisLine->lineWidth += charWidth;
        !          1423:        } else if (*str == NEWLINE) {
        !          1424:            HandleNewLine(display, textInfo, 0);
        !          1425:        } else if (*str == NEWFONT) {
        !          1426:            /* Go into waiting for font number mode */
        !          1427:            textInfo->flagWord |= FONTNUMWAIT;
        !          1428:        } else if (*str == BACKSPACE) {
        !          1429:            HandleBackspace(display, textInfo, 0);
        !          1430:        } else {
        !          1431:            /* Ignore all others */
        !          1432:        }
        !          1433:     }
        !          1434:     textInfo->flagWord |= SCREENWRONG;
        !          1435:     return 1;
        !          1436: }
        !          1437: 
        !          1438: 
        !          1439: 
        !          1440: int TxtRepaint(display,w)
        !          1441: Display *display;
        !          1442: Window w;
        !          1443: /*
        !          1444:  * Repaints the given scrollable text window.  The routine repaints
        !          1445:  * the entire window.  For handling exposure events,  the TxtFilter 
        !          1446:  * routine should be used.
        !          1447:  */
        !          1448: {
        !          1449:     struct txtWin *textInfo;
        !          1450:     int index, ypos;
        !          1451: 
        !          1452:     if ((textInfo = (struct txtWin *) XLookUpAssoc(display, textWindows, (XID) w)
        !          1453:         ) == 0)
        !          1454:       return 0;
        !          1455: 
        !          1456:     /* Check to see if the screen is up to date */
        !          1457:     if (textInfo->flagWord & SCREENWRONG) {
        !          1458:        textInfo->endLine = FindEndLine(textInfo, &(textInfo->bottomSpace));
        !          1459:        textInfo->flagWord &= (~SCREENWRONG);
        !          1460:     }
        !          1461: 
        !          1462:     ypos = YPADDING;
        !          1463:     index = textInfo->startLine;
        !          1464:     for (;;) {
        !          1465:        DrawLine(display, textInfo, index, ypos);
        !          1466:        if (index >= textInfo->endLine) break;
        !          1467:        ypos += (textInfo->txtBuffer[index]->lineHeight + INTERLINE);
        !          1468:        index++;
        !          1469:     }
        !          1470:     /* Draw the cursor (if on screen) */
        !          1471:     if (textInfo->endLine == textInfo->curLine) {
        !          1472:        XFillRectangle(display, w, textInfo->CursorGC,
        !          1473:                       textInfo->txtBuffer[index]->lineWidth + CUROFFSET,
        !          1474:                       ypos /* + textInfo->txtBuffer[index]->lineHeight */,
        !          1475:                       CURSORWIDTH, textInfo->txtBuffer[index]->lineHeight);
        !          1476: 
        !          1477:     }
        !          1478:     /* Update the scroll bar */
        !          1479:     UpdateScroll(display, textInfo);
        !          1480:     return 1;
        !          1481: }
        !          1482: 
        !          1483: 
        !          1484: 
        !          1485: static int InsertIndex(textInfo, thisIndex, ypos)
        !          1486: struct txtWin *textInfo;       /* Text Window Information    */
        !          1487: int thisIndex;                 /* Line index of exposed line */
        !          1488: int ypos;                      /* Drawing position of line   */
        !          1489: /*
        !          1490:  * This routine inserts the supplied line index into the copy
        !          1491:  * exposure array for 'textInfo'.  The array is kept sorted
        !          1492:  * from lowest to highest using insertion sort.  The array
        !          1493:  * is dynamically expanded if needed.
        !          1494:  */
        !          1495: {
        !          1496:     struct expEvent *newItem;
        !          1497:     int newSize, index, downIndex;
        !          1498: 
        !          1499:     /* Check to see if we need to expand it */
        !          1500:     if ((textInfo->exposeSize + 3) >= textInfo->exposeAlloc) {
        !          1501:        newSize = textInfo->exposeAlloc +
        !          1502:          (textInfo->exposeAlloc * EXPANDPERCENT / 100);
        !          1503:        textInfo->exposeAry = (struct expEvent **)
        !          1504:          realloc((char *) textInfo->exposeAry,
        !          1505:                  (unsigned) (newSize * sizeof(struct expEvent *)));
        !          1506:        for (index = textInfo->exposeAlloc;  index < newSize;  index++)
        !          1507:          textInfo->exposeAry[index] = alloc(struct expEvent);
        !          1508:        textInfo->exposeAlloc = newSize;
        !          1509:     }
        !          1510:     /* Find spot for insertion.  NOTE: last spot has big number */
        !          1511:     for (index = 0;  index <= textInfo->exposeSize;  index++) {
        !          1512:        if (textInfo->exposeAry[index]->lineIndex >= thisIndex) {
        !          1513:            if (textInfo->exposeAry[index]->lineIndex > thisIndex) {
        !          1514:                /* Insert before this entry */
        !          1515:                newItem = textInfo->exposeAry[textInfo->exposeSize+1];
        !          1516:                for (downIndex = textInfo->exposeSize;
        !          1517:                     downIndex >= index;
        !          1518:                     downIndex--)
        !          1519:                  {
        !          1520:                      textInfo->exposeAry[downIndex+1] =
        !          1521:                        textInfo->exposeAry[downIndex];
        !          1522:                  }
        !          1523:                /* Put a free structure at this spot */
        !          1524:                textInfo->exposeAry[index] = newItem;
        !          1525:                /* Fill it in */
        !          1526:                textInfo->exposeAry[index]->lineIndex = thisIndex;
        !          1527:                textInfo->exposeAry[index]->ypos = ypos;
        !          1528:                /* Break out of loop */
        !          1529:                textInfo->exposeSize += 1;
        !          1530:            }
        !          1531:            break;
        !          1532:        }
        !          1533:     }
        !          1534:     return 1;
        !          1535: }
        !          1536: 
        !          1537: 
        !          1538: 
        !          1539: static int ScrollUp(display, textInfo)
        !          1540: Display *display;
        !          1541: struct txtWin *textInfo;       /* Text window information   */
        !          1542: /*
        !          1543:  * This routine scrolls the indicated text window up by one
        !          1544:  * line.  The line above the current line must exist.  The
        !          1545:  * window is scrolled so that the line above the start line
        !          1546:  * is displayed at the top of the screen.  This may cause
        !          1547:  * many lines to scroll off the bottom.  The scrolling is
        !          1548:  * done using XCopyArea.  The exposure events should be caught
        !          1549:  * by ExposeCopy.
        !          1550:  */
        !          1551: {
        !          1552:     int targetSpace;
        !          1553: 
        !          1554:     /* Make sure all exposures have been handled by now */
        !          1555:     if (textInfo->startLine == 0) return 0;
        !          1556:     targetSpace = textInfo->txtBuffer[textInfo->startLine-1]->lineHeight +
        !          1557:       INTERLINE;
        !          1558:     /* Move the area downward by the target amount */
        !          1559:     XCopyArea(display, textInfo->mainWindow, textInfo->mainWindow,
        !          1560:              DEFAULT_GC,
        !          1561:              0, YPADDING, textInfo->w - BARSIZE,
        !          1562:              textInfo->h, 0, targetSpace);
        !          1563: 
        !          1564:     textInfo->flagWord |= COPYEXPOSE;
        !          1565:     /* Update the text window parameters */
        !          1566:     textInfo->startLine -= 1;
        !          1567:     textInfo->endLine = FindEndLine(textInfo, &(textInfo->bottomSpace));
        !          1568: 
        !          1569:     /* Clear out bottom space region */
        !          1570:     XClearArea(display, textInfo->mainWindow,
        !          1571:               0, textInfo->h - textInfo->bottomSpace,
        !          1572:               textInfo->w, textInfo->bottomSpace);
        !          1573:     
        !          1574:     UpdateExposures(display, textInfo);
        !          1575:     UpdateScroll(display, textInfo);
        !          1576: 
        !          1577:     return 1;
        !          1578: }
        !          1579: 
        !          1580: 
        !          1581: static int ScrollToSpot(display, textInfo, ySpot)
        !          1582: Display *display;
        !          1583: struct txtWin *textInfo;       /* Text window information          */
        !          1584: int ySpot;                     /* Button position in scroll window */
        !          1585: /*
        !          1586:  * This routine scrolls the specified text window relative to the
        !          1587:  * position of the mouse in the scroll bar.  The center of the screen
        !          1588:  * will be positioned to correspond to the mouse position.
        !          1589:  */
        !          1590: {
        !          1591:     int targetLine, aboveLines;
        !          1592: 
        !          1593:     targetLine = textInfo->numLines * ySpot / textInfo->h;
        !          1594:     textInfo->startLine = targetLine;
        !          1595:     textInfo->endLine = FindEndLine(textInfo, &(textInfo->bottomSpace));
        !          1596:     aboveLines = 0;
        !          1597:     /* Make the target line the *center* of the window */
        !          1598:     while ((textInfo->startLine > 0) &&
        !          1599:           (aboveLines < textInfo->endLine - targetLine))
        !          1600:       {
        !          1601:          textInfo->startLine -= 1;
        !          1602:          textInfo->endLine = FindEndLine(textInfo, &(textInfo->bottomSpace));
        !          1603:          aboveLines++;
        !          1604:       }
        !          1605:     if (textInfo->endLine == textInfo->numLines-1) {
        !          1606:        WarpToBottom(display, textInfo);
        !          1607:     } else {
        !          1608:        XClearWindow(display, textInfo->mainWindow);
        !          1609:        TxtRepaint(display, textInfo->mainWindow);
        !          1610:     }
        !          1611:     return 1;
        !          1612: }
        !          1613: 
        !          1614: 
        !          1615: 
        !          1616: static int LineToTop(display, textInfo, pos)
        !          1617: Display *display;
        !          1618: struct txtWin *textInfo;       /* Text window information */
        !          1619: int pos;                       /* Y position of mouse     */
        !          1620: /*
        !          1621:  * This routine scrolls the screen down until the line at the
        !          1622:  * mouse position is at the top of the screen.  It stops
        !          1623:  * if it can't scroll the buffer down that far.  If the
        !          1624:  * global 'ScrollOption' is NORMSCROLL,  a smooth scroll
        !          1625:  * is used.  Otherwise,  it jumps to the right position
        !          1626:  * and repaints the screen.
        !          1627:  */
        !          1628: {
        !          1629:     int index, sum;
        !          1630: 
        !          1631:     /* First,  we find the current line */
        !          1632:     sum = 0;
        !          1633:     for (index = textInfo->startLine;  index <= textInfo->endLine;  index++) {
        !          1634:        if (sum + textInfo->txtBuffer[index]->lineHeight + INTERLINE> pos) break;
        !          1635:        sum += textInfo->txtBuffer[index]->lineHeight + INTERLINE;
        !          1636:     }
        !          1637:     /* We always want to scroll down at least one line */
        !          1638:     if (index == textInfo->startLine) index++;
        !          1639:     if (ScrollOption == NORMSCROLL) {
        !          1640:        /* Scroll down until 'index' is the starting line */
        !          1641:        while ((textInfo->startLine < index) && ScrollDown(display, textInfo))
        !          1642:        {
        !          1643:            /* Empty Loop Body */
        !          1644:        }
        !          1645:     } else {
        !          1646:        /* Immediately jump to correct spot */
        !          1647:        textInfo->startLine = index;
        !          1648:        textInfo->endLine = FindEndLine(textInfo, &(textInfo->bottomSpace));
        !          1649:        if (textInfo->endLine == textInfo->numLines-1) {
        !          1650:            WarpToBottom(display, textInfo);
        !          1651:        } else {
        !          1652:            XClearWindow(display, textInfo->mainWindow);
        !          1653:            TxtRepaint(display, textInfo->mainWindow);
        !          1654:        }
        !          1655:     }
        !          1656:     /* Check to see if at end of buffer */
        !          1657:     if (textInfo->endLine >= textInfo->numLines-1) {
        !          1658:        textInfo->flagWord &= (~NOTATBOTTOM);
        !          1659:     }
        !          1660:     return 1;
        !          1661: }
        !          1662: 
        !          1663: 
        !          1664: 
        !          1665: static int TopToHere(display, textInfo, pos)
        !          1666: Display *display;
        !          1667: struct txtWin *textInfo;       /* Text window information */
        !          1668: int pos;                       /* Y position of mouse     */
        !          1669: /*
        !          1670:  * This routine scrolls the screen up until the top line of
        !          1671:  * the screen is at the current Y position of the mouse.  Again,
        !          1672:  * it will stop if it can't scroll that far.  If the global
        !          1673:  * 'ScrollOption' is NORMSCROLL,  a smooth scroll is used.
        !          1674:  * If it's not,  it will simply redraw the screen at the
        !          1675:  * correct spot.
        !          1676:  */
        !          1677: {
        !          1678:     int sum, target, linesup, index;
        !          1679: 
        !          1680:     target = pos - textInfo->txtBuffer[textInfo->startLine]->lineHeight;
        !          1681:     /* We always want to scroll up at least one line */
        !          1682:     if (target <= 0) target = 1;
        !          1683:     sum = 0;
        !          1684:     linesup = 0;
        !          1685:     /* Check to see if we are at the top anyway */
        !          1686:     if (textInfo->startLine == 0) return 0;
        !          1687:     if (ScrollOption == NORMSCROLL) {
        !          1688:        /* Scroll up until sum of new top lines greater than target */
        !          1689:        while ((sum < target) && ScrollUp(display, textInfo)) {
        !          1690:            sum += textInfo->txtBuffer[textInfo->startLine]->lineHeight;
        !          1691:            linesup++;
        !          1692:        }
        !          1693:     } else {
        !          1694:        /* Search backward to find index */
        !          1695:        index = textInfo->startLine - 1;
        !          1696:        while ((index > 0) && (sum < target)) {
        !          1697:            sum += textInfo->txtBuffer[index]->lineHeight;
        !          1698:            linesup++;
        !          1699:            index--;
        !          1700:        }
        !          1701:        /* Go directly to the index */
        !          1702:        textInfo->startLine = index;
        !          1703:        textInfo->endLine = FindEndLine(textInfo, &(textInfo->bottomSpace));
        !          1704:        XClearWindow(display, textInfo->mainWindow);
        !          1705:        TxtRepaint(display, textInfo->mainWindow);
        !          1706:     }
        !          1707:     /* If we scrolled,  assert we are not at bottom of buffer */
        !          1708:     if (linesup > 0) {
        !          1709:        textInfo->flagWord |= NOTATBOTTOM;
        !          1710:     }
        !          1711:     return 1;
        !          1712: }
        !          1713: 
        !          1714: 
        !          1715: 
        !          1716: int TxtFilter(display, evt)
        !          1717: Display *display;
        !          1718: XEvent *evt;
        !          1719: /*
        !          1720:  * This routine handles events associated with scrollable text windows.
        !          1721:  * It will handle all exposure events and any button released events
        !          1722:  * in the scroll bar of a text window.  It does NOT handle any other
        !          1723:  * events.  If it cannot handle the event,  it will return 0.
        !          1724:  */
        !          1725: {
        !          1726:     XExposeEvent *expose = &evt->xexpose;
        !          1727:     XButtonEvent *btEvt = &evt->xbutton;
        !          1728:     XGraphicsExposeEvent *gexpose = &evt->xgraphicsexpose;
        !          1729:     XNoExposeEvent *noexpose = &evt->xnoexpose;
        !          1730:     struct txtWin *textInfo;
        !          1731:     int index, ypos;
        !          1732:     Window w, sw;
        !          1733: 
        !          1734:     if (textWindows == (XAssocTable *) 0) {
        !          1735:        textWindows = XCreateAssocTable(32);
        !          1736:        if (textWindows == (XAssocTable *) 0) return(0);
        !          1737:     }
        !          1738:     if (evt->type == Expose) {
        !          1739:        w = expose->window;
        !          1740:        sw = 0;
        !          1741:     }
        !          1742:     else if (evt->type == GraphicsExpose) {
        !          1743:        w = gexpose->drawable;
        !          1744:        sw = 0;
        !          1745:     }
        !          1746:     else if (evt->type == NoExpose) {
        !          1747:        w = noexpose->drawable;
        !          1748:        sw = 0;
        !          1749:     }
        !          1750:     else if (evt->type == ButtonRelease) {
        !          1751:        w = btEvt->window;
        !          1752:        sw = btEvt->subwindow;
        !          1753:     }
        !          1754:     else
        !          1755:        return 0;
        !          1756: 
        !          1757:     if ((textInfo = (struct txtWin *)
        !          1758:         XLookUpAssoc(display, textWindows, (XID) w)) == 0)     
        !          1759:        return 0;
        !          1760: 
        !          1761:     /* Determine whether it's main window or not */
        !          1762:     if ((w == textInfo->mainWindow) && (sw == 0)) {
        !          1763:        /* Main Window - handle exposures */
        !          1764:        switch (evt->type) {
        !          1765:        case Expose:
        !          1766:            ypos = 0 /*YPADDING*/;
        !          1767:            for (index = textInfo->startLine;
        !          1768:                 index <= textInfo->endLine;
        !          1769:                 index++)
        !          1770:              {
        !          1771:                  int lh = textInfo->txtBuffer[index]->lineHeight;
        !          1772: 
        !          1773:                  if (((ypos + lh) >= expose->y) &&
        !          1774:                      (ypos <= (expose->y + expose->height)))
        !          1775:                    {
        !          1776:                        /* Intersection region */
        !          1777:                        /* Draw line immediately */
        !          1778:                        DrawLine(display, textInfo, index, ypos);
        !          1779:                        /* And possibly draw cursor */
        !          1780:                        if (textInfo->curLine == index) {
        !          1781:                            XFillRectangle(display, w, textInfo->CursorGC,
        !          1782:                                       textInfo->txtBuffer[index]->lineWidth +
        !          1783:                                           CUROFFSET,
        !          1784:                                           ypos,
        !          1785:                                           CURSORWIDTH,
        !          1786:                                           lh);
        !          1787:                        }
        !          1788:                    }
        !          1789:                  ypos += lh + INTERLINE;
        !          1790:              }
        !          1791:            break;
        !          1792:        case GraphicsExpose:
        !          1793:            ypos = 0 /*YPADDING*/;
        !          1794:            for (index = textInfo->startLine;
        !          1795:                 index <= textInfo->endLine;
        !          1796:                 index++)
        !          1797:              {
        !          1798:                  int lh = textInfo->txtBuffer[index]->lineHeight;
        !          1799: 
        !          1800:                  if (((ypos + lh) >= gexpose->y) &&
        !          1801:                      (ypos <= (gexpose->y + gexpose->height)))
        !          1802:                    {
        !          1803:                        /* Intersection region */
        !          1804:                        /* Draw line immediately */
        !          1805:                        DrawLine(display, textInfo, index, ypos);
        !          1806:                        /* And possibly draw cursor */
        !          1807:                        if (textInfo->curLine == index) {
        !          1808:                            XFillRectangle(display, w, textInfo->CursorGC,
        !          1809:                                    textInfo->txtBuffer[index]->lineWidth +
        !          1810:                                    CUROFFSET,
        !          1811:                                    ypos,
        !          1812:                                    CURSORWIDTH,
        !          1813:                                    lh);
        !          1814:                        }
        !          1815:                    }
        !          1816:                  ypos += lh + INTERLINE;
        !          1817:              }
        !          1818:            break;
        !          1819:        case NoExpose:
        !          1820:            break;
        !          1821:        default:
        !          1822:            /* Not one of our events */
        !          1823:            return 0;
        !          1824:        }
        !          1825:     } else {
        !          1826:        switch (evt->type) {
        !          1827:        case Expose:
        !          1828:            UpdateScroll(display, textInfo);
        !          1829:            break;
        !          1830:        case ButtonRelease:
        !          1831:            /* Find out which button */
        !          1832:            switch (btEvt->button) {
        !          1833:            case Button1:
        !          1834:                /* Scroll up until top line is at mouse position */
        !          1835:                TopToHere(display, textInfo, btEvt->y);
        !          1836:                break;
        !          1837:            case Button2:
        !          1838:                /* Scroll to spot relative to position */
        !          1839:                ScrollToSpot(display, textInfo, btEvt->y);
        !          1840:                if (textInfo->endLine >= textInfo->numLines-1) {
        !          1841:                    textInfo->flagWord &= (~NOTATBOTTOM);
        !          1842:                } else {
        !          1843:                    textInfo->flagWord |= NOTATBOTTOM;
        !          1844:                }
        !          1845:                break;
        !          1846:            case Button3:
        !          1847:                /* Scroll down until pointed line is at top */
        !          1848:                LineToTop(display, textInfo, btEvt->y);
        !          1849:                break;
        !          1850:            }
        !          1851:            break;
        !          1852:        default:
        !          1853:            /* Not one of our events */
        !          1854:            return 0;
        !          1855:        }
        !          1856:     }
        !          1857:     return 1;
        !          1858: }

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