![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Xtextlib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / Xlib|
Return to Xtextlib.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / Xlib |
1.1 root 1: /* $Header: Xtextlib.c,v 10.6 86/04/23 12:03:28 jg Rel $ */
2: /* Library of routines for creating a simple text output window.
3: *
4: * Routines in the library are:
5: *
6: * TextCreate Creates a new instance of a text window
7: * TextDestroy Destroys the window
8: * TextClear Clears a text window
9: * TextRedisplay Redisplays one or all windows
10: * TextEvent Handles exposure and unmapping events
11: * TextFlush Flush and handle all outstanding events for
12: * one or all TextWindows.
13: * TextPutString Displays a string in a text window
14: * TextPutChar Displays a character in a text window
15: * TextPrintf Does a printf in a text window
16: *
17: * Most of these routines pass around a pointer to a TextWindow data structure:
18: *
19: * typedef struct _TextWindow {
20: * Window w; Window to use
21: * FontInfo *font; Font to use for text
22: * short num_lines; Number of lines in the window
23: * short num_chars; The length of each line
24: * short mapped; Whether or not the window is mapped
25: * short height; Height of window in pixels
26: * short width; Width of window in pixels
27: * short first_line; The index of the first line
28: * char **lines; Ptr to array of text lines
29: * short *line_length; Ptr to array of line lengths (in pixels)
30: * short *line_chars; Ptr to array of line lengths in chars
31: * short last_line; Which line is the last
32: * short last_char; Length of the last line
33: * short next_x; X-coord for next character
34: * short next_y; Y-coord for next character
35: * unsigned int eventmask; List of events we're interested in
36: * char *scroll_history; Ptr to list of scroll amounts
37: * short scroll_count; Number of outstanding scrolls
38: * short scroll_start; Where in the history the history starts
39: * short old_scrolls; Number of ignorable outstanding scrolls
40: * short fastscroll; Whether or not to use fast scrolling
41: * } TextWindow;
42: *
43: * Applications should not modify anything in this data structure, obviously!
44: * They may, however, have reason to get information out of it. (Such as the
45: * window id for mapping).
46: *
47: * Information about the first line of the window is stored in the array
48: * entries subscripted by [first_line]; the arrays wrap back up at the end.
49: * Last_char should always be the same as line_chars[last_line].
50: * Similarly, next_x should always be the same as line_length[last_line];
51: *
52: * The only complicated thing about these procedures is the way they keep
53: * track of scrolling. When a scroll is done, X sends ExposeRegions for
54: * every region that needs to be patched up and then an ExposeCopy event.
55: * The ExposeCopy comes even if there were no regions. The only problem
56: * is that more scrolls may have been done in the meantime. So we keep a
57: * history of how much cumulative scrolling has been done in the
58: * scroll_history list. scroll_start tells which one to start with, and
59: * scroll_count tells how many there are (they wrap around). The list is
60: * num_lines long since anything that's scrolled away longer ago than that
61: * has scrolled off the screen. The old_scrolls field gets set whenever the
62: * screen is fully updated for some reason or other; it means that that
63: * many ExposeCopy events can be completely ignored since the screen has
64: * been fully updated.
65: */
66:
67: #include <stdio.h>
68: #include "Xtext.h"
69:
70: #ifndef TRUE
71: #define TRUE 1
72: #define FALSE 0
73: #endif
74:
75: /* Define the width of the left margin */
76:
77: #define mar_width 2
78:
79: char *calloc(), *malloc(), *realloc();
80:
81: /* The following variable is sometimes set by TextPutString to temporarily
82: disable screen updating. */
83:
84: static int dont_update = FALSE;
85:
86: /*
87: * the following variable is the head pointer to a list of TextWindows
88: */
89: static TextWindow *head=NULL;
90:
91:
92: /*
93: * add a new TextWindow to the list of TextWindows created for this
94: * process.
95: */
96: static AddTextWindow(t)
97: TextWindow *t;
98: {
99: TextWindow *p;
100:
101: t->next = NULL;
102: if (head) {
103: p = head;
104: while (p->next) p = p->next;
105: p->next = t;
106: } else {
107: head = t;
108: }
109: }
110:
111:
112: /*
113: * delete a TextWindow from the list of TextWindows created for this
114: * process.
115: */
116: static DelTextWindow(t)
117: TextWindow *t;
118: {
119: TextWindow *p=head;
120:
121: if (!p) return; /* shouldn't happen! no list. */
122: if (p==t) {
123: head = t->next;
124: } else {
125: while (p->next && (t != p->next)) p = p->next;
126: if (t != p->next) return; /* shouldn't happen! not found */
127: p->next = t->next;
128: }
129: }
130:
131: /* TextCreate creates a new window which will use the
132: * specified font. The window is height lines high and width
133: * characters wide. Note that since a variable-width font may be
134: * used, the width is calculated using the average width of the font.
135: * Colors are used as specified.
136: */
137:
138: TextWindow *TextCreate (width, height, x, y, parent, fontname,
139: bwidth, fgpixel, bgpixel, bordercolor, fastscroll)
140: int height, width, x, y, bwidth, fastscroll;
141: Window parent;
142: char *fontname;
143: int fgpixel, bgpixel;
144: Pixmap bordercolor;
145: {
146: register TextWindow *t;
147: register int i;
148: register FontInfo *f;
149: Window XCreateWindow();
150: Pixmap bgpixmap;
151:
152: if ((t = (TextWindow *) malloc(sizeof(TextWindow))) ==
153: NULL) return NULL;
154:
155: AddTextWindow(t); /* add to list of TextWindows */
156:
157: if ((f = t->font = XOpenFont(fontname)) == NULL) {
158: TextDestroy(t);
159: return NULL;
160: }
161:
162: t->fgpixel = fgpixel;
163: t->bgpixel = bgpixel;
164:
165: if ((bgpixmap = XMakeTile(bgpixel)) == NULL) {
166: TextDestroy(t);
167: return NULL;
168: }
169:
170: t->width = width * f->width + mar_width;
171: t->height = height * f->height;
172:
173: t->w = XCreateWindow (parent, x, y, t->width, t->height,
174: bwidth, bordercolor, bgpixmap);
175: if (t->w == NULL) {
176: TextDestroy(t);
177: XFreePixmap(bgpixmap);
178: return NULL;
179: }
180:
181: XFreePixmap(bgpixmap);
182:
183: t->eventmask = ExposeRegion | ExposeWindow | ExposeCopy | UnmapWindow;
184: /* (ExposeRegion automatically selects ExposeWindow) */
185:
186: XSelectInput (t->w, t->eventmask);
187:
188: XSetResizeHint (t->w, mar_width, 0, f->width, f->height);
189: t->fastscroll = fastscroll;
190: t->mapped = FALSE;
191: t->num_lines = height;
192: t->num_chars = width;
193:
194: t->first_line = 0;
195:
196: if ((t->lines = (char **)
197: calloc (height, sizeof (char *))) == NULL) {
198: TextDestroy(t);
199: return NULL;
200: }
201:
202: if ((t->line_length = (short *)
203: calloc (height, sizeof (short))) == NULL) {
204: TextDestroy(t);
205: return NULL;
206: }
207:
208: if ((t->line_chars = (short *)
209: calloc (height, sizeof (short))) == NULL) {
210: TextDestroy(t);
211: return NULL;
212: }
213:
214: for (i = 0; i < height; i++) {
215: if ((t->lines[i] = (char *)
216: calloc (width+1, sizeof (char))) == NULL) {
217: TextDestroy(t);
218: return NULL;
219: }
220: }
221:
222: if ((t->scroll_history = calloc(height, sizeof (char))) == NULL) {
223: TextDestroy(t);
224: return NULL;
225: }
226:
227: t->scroll_count = t->scroll_start = t->old_scrolls = 0;
228: TextClear(t);
229: return t;
230: }
231:
232: /* Free all the storage associated with a textwindow */
233:
234: TextDestroy(t)
235: register TextWindow *t;
236: {
237: register int i;
238:
239: /* Free things in the order we allocated them. If something doesn't
240: exist, don't free it!) */
241:
242: if (t->font) {
243: if (t->font->fixedwidth == 0) free((char *)t->font->widths);
244: free((char *)t->font);
245: }
246:
247: if (t->w) XDestroyWindow(t->w);
248:
249: if (t->lines) {
250: for (i = 0; i < t->num_lines; i++) {
251: if (t->lines[i]) free((char *)t->lines[i]);
252: }
253: free((char *)t->lines);
254: }
255:
256: if (t->line_length) free ((char *)t->line_length);
257: if (t->line_chars) free ((char *)t->line_chars);
258: if (t->scroll_history) free (t->scroll_history);
259:
260:
261: DelTextWindow(t); /* remove from list of TextWindows */
262:
263: /* And finally the data structure itself! */
264: free ((char *)t);
265: }
266:
267: /* Clear out a text window and redisplay */
268:
269: TextClear(t)
270: register TextWindow *t;
271: {
272: register int i;
273:
274: for (i = 0; i < t->num_lines; i++) {
275: t->lines[i][0] = '\0';
276: t->line_chars[i] = 0;
277: t->line_length[i] = mar_width; /* Allow a left margin */
278: }
279: t->last_line = 0;
280: t->last_char = 0;
281: t->next_x = mar_width; /* Allow a left margin */
282: t->next_y = 0;
283: t->first_line = 0;
284:
285: TextRedisplay(t);
286: }
287:
288: /* Redisplays a text window */
289:
290: TextRedisplay (t)
291: register TextWindow *t;
292: {
293: if (t==NULL) {
294: for (t = head; t!=NULL; t = t->next) {
295: TextRedisplay(t);
296: }
297: return;
298: }
299: if (!t->mapped) return;
300:
301: /* Clear the border area */
302:
303: XPixSet(t->w, 0, 0, mar_width, t->height, t->bgpixel);
304:
305: Redisplay_lines(t, 0, t->num_lines - 1);
306:
307: /* Any outstanding copies from scrolls can now be ignored */
308:
309: t->old_scrolls = t->scroll_count;
310: t->scroll_count = t->scroll_start = 0;
311: }
312:
313: Redisplay_lines(t, start, finish)
314: register TextWindow *t;
315: int start, finish;
316: {
317: register int i, j, y, height = t->font->height, x, width;
318:
319: if (finish < 0) return;
320: if (start < 0) start = 0;
321:
322: y = start * height;
323: j = start + t->first_line;
324:
325: for (i = start; i <= finish; i++) {
326: if (j >= t->num_lines) j = 0;
327:
328: if (t->line_chars[j]) {
329: XText (t->w, mar_width, y, t->lines[j], t->line_chars[j],
330: t->font->id, t->fgpixel, t->bgpixel);
331: }
332:
333: x = t->line_length[j];
334: width = t->width - x;
335:
336: if (width > 0) XPixSet(t->w, x, y, width, height, t->bgpixel);
337: y += height;
338: j++;
339: }
340: }
341:
342: /* Handles an event. If it's not an event it knows how to deal with,
343: returns TRUE, otherwise FALSE. */
344:
345: int TextEvent(t, e)
346: register TextWindow *t;
347: XEvent *e;
348: {
349: XExposeEvent *ee = (XExposeEvent *) e;
350: int offset;
351:
352: switch (e->type) {
353: case ExposeWindow:
354: if (ee->height != t->height || ee->width != t->width) {
355: Change_text_window_size(t, ee->height / t->font->height,
356: ee->width / t->font->width);
357: }
358: t->mapped = TRUE;
359: TextRedisplay(t);
360: break;
361:
362: case ExposeRegion:
363: /* If there have been more scrolls than there are lines,
364: this stuff has already scrolled off! */
365:
366: if (t->scroll_count > t->num_lines) return FALSE;
367:
368: /* If this is for an old scroll, ignore it */
369:
370: if (ee->detail == ExposeCopy && t->old_scrolls) return FALSE;
371:
372: if (t->scroll_count > 0) {
373: offset = t->scroll_history[t->scroll_start];
374: } else offset = 0;
375: Redisplay_lines(t, ee->y / t->font->height - offset,
376: (ee->y + ee->height - 1) / t->font->height - offset);
377: break;
378:
379: case UnmapWindow:
380: t->mapped = FALSE;
381: break;
382:
383: case ExposeCopy: /* We've finished the events for one scroll */
384: /* If there are old scrolls, just decrement the count and
385: return */
386:
387: if (t->old_scrolls) {
388: t->old_scrolls--;
389: return FALSE;
390: }
391: t->scroll_count--;
392: if (t->scroll_count < t->num_lines) {
393: t->scroll_start++;
394: if (t->scroll_start >= t->num_lines) t->scroll_start = 0;
395: }
396: break;
397:
398: default:
399: return TRUE;
400: }
401: return FALSE;
402: }
403:
404: /*
405: * Flush all outstanding events for all existent TextWindows.
406: */
407: TextFlush(t)
408: TextWindow *t;
409: {
410: XEvent e;
411:
412: if (t==NULL) {
413: for (t=head; t!=NULL; t=t->next) {
414: TextFlush(t);
415: }
416: return;
417: }
418:
419: XSync(0);
420:
421: while (XCheckWindowEvent(t->w,t->eventmask|ExposeWindow,&e)) {
422: if (TextEvent(t,&e)) {
423: /*
424: * We should never get here. Accordingly, we
425: * don't do anything if we do, somehow, get here.
426: */
427: }
428: }
429:
430: }
431:
432: Change_text_window_size (t, new_h, new_w)
433: register TextWindow *t;
434: register int new_h, new_w;
435: {
436: register int i;
437: register char *curline;
438:
439: Normalize(t); /* Rearrange lines so that first_line = 0 */
440:
441: /* First free up any now extraneous lines */
442:
443: for (i = new_h; i < t->num_lines; i++) free((char *)t->lines[i]);
444:
445: if ((t->lines = (char **)
446: realloc((char *)t->lines, new_h * sizeof (char *))) == NULL) {
447: return;
448: }
449:
450: if ((t->line_length = (short *)
451: realloc((char *)t->line_length, new_h * sizeof (short))) == NULL) {
452: return;
453: }
454:
455: if ((t->line_chars = (short *)
456: realloc((char *)t->line_chars, new_h * sizeof (short))) == NULL) {
457: return;
458: }
459:
460: if ((t->scroll_history = realloc(t->scroll_history, new_h)) == NULL) {
461: return;
462: }
463:
464: for (i = 0; i < new_h; i++) {
465: if (i < t->num_lines) {
466: if ((curline = t->lines[i] =
467: realloc(t->lines[i], new_w + 1)) == NULL) {
468: return;
469: }
470:
471: if (t->line_chars[i] > new_w) {
472: t->line_chars[i] = new_w;
473: curline[new_w] = '\0'; /* Truncate the line */
474: t->line_length[i] = mar_width +
475: XStringWidth (curline, t->font, 0, 0);
476: }
477: } else {
478: if ((t->lines[i] = malloc(new_w+1)) == NULL) {
479: return;
480: }
481: t->lines[i][0] = '\0';
482: t->line_chars[i] = 0;
483: t->line_length[i] = mar_width;
484: }
485: }
486:
487: if (t->last_line >= new_h) {
488: t->last_line = new_h - 1;
489: t->last_char = t->line_chars[t->last_line];
490: t->next_x = t->line_length[t->last_line];
491: t->next_y = t->last_line * t->font->height;
492:
493: } else if (t->last_char > new_w) {
494: t->last_char = t->line_chars[t->last_line];
495: t->next_x = t->line_length[t->last_line];
496: }
497:
498: t->num_lines = new_h;
499: t->num_chars = new_w;
500: t->height = new_h * t->font->height;
501: t->width = new_w * t->font->width + mar_width;
502: }
503:
504: /* Routine to re-arrange the lines in a window structure so that first_line
505: is equal to 0. */
506:
507: Normalize(t)
508: register TextWindow *t;
509: {
510: if (t->first_line == 0) return;
511:
512: t->last_line -= t->first_line;
513: if (t->last_line < 0) t->last_line += t->num_lines;
514:
515: Spin_lines(t, 0, t->num_lines-1, t->first_line);
516:
517: t->first_line = 0;
518: }
519:
520: /* Spin lines rotates the m through n lines of the arrays
521: forward offset places. For example, 012345 spun forward 2 is 234501.
522: It's straightforward to spin the first part of the arrays; and we
523: call Spin_lines recursively to do the last offset elements */
524:
525: /* Actually, it's tail-recursive, so I just use a loop. But I can
526: pretend, can't I? */
527:
528: Spin_lines(t, m, n, offset)
529: register TextWindow *t;
530: int m, n;
531: register int offset;
532: {
533: register int i;
534: register int temp; /* Temporaries */
535: register char *tempc;
536:
537: while (1) {
538: if (offset == 0 || offset > n-m) return;
539:
540: for (i = m; i <= n-offset; i++) {
541: temp = t->line_length[i];
542: t->line_length[i] = t->line_length[offset+i];
543: t->line_length[offset+i] = temp;
544:
545: temp = t->line_chars[i];
546: t->line_chars[i] = t->line_chars[offset+i];
547: t->line_chars[offset+i] = temp;
548:
549: tempc = t->lines[i];
550: t->lines[i] = t->lines[offset+i];
551: t->lines[offset+i] = tempc;
552: }
553:
554: /* Spin_lines(t, n-offset+1, n, offset - ((n-m+1) % offset)); */
555:
556: temp = m;
557: m = n - offset + 1;
558: offset -= (n - temp + 1) % offset;
559: }
560: }
561:
562: /* Routine to put a string in a text window. If fastscroll is
563: set in the TextWindow structure, a single block scroll is done instead
564: of scrolling at each newline. */
565:
566: #define verybig 10000 /* Amount to scroll if we should refresh instead */
567:
568: TextPutString (t, str)
569: register TextWindow *t;
570: register char *str;
571: {
572: register char *ch = str;
573: register char oldch;
574: int jump = t->fastscroll; /* Whether to do jump scrolling */
575: int newlines, scroll;
576:
577: if (jump) jump = Count_lines (t, str, &newlines, &scroll);
578:
579: while (1) {
580: while (*ch != '\0' && *ch != '\n') ch++;
581: if (ch != str) {
582: oldch = *ch;
583: *ch = '\0';
584: Do_text_string (t, str);
585: *ch = oldch;
586: }
587: if (*ch == '\0') break;
588: if (jump && newlines == scroll) {
589: Clear_lines (t, newlines);
590: dont_update = TRUE; /* Stop updating now */
591: }
592: newlines--;
593: TextPutChar (t, *ch);
594: str = ++ch;
595: }
596: if (t->mapped && jump) {
597: if (scroll != verybig) Scroll_text_window (t, scroll);
598: else TextRedisplay (t);
599: }
600: dont_update = FALSE;
601: }
602:
603: /* Count the number of lines in str, calculate how much scrolling
604: will be needed, and return whether this amount is positive */
605:
606: int Count_lines (t, str, newlines, scroll)
607: register TextWindow *t;
608: register char *str;
609: int *newlines, *scroll;
610: {
611: register int num_lines = 0;
612: register int lines_left, height = t->num_lines;
613:
614: *scroll = 0;
615:
616: while (*str) {
617: if (*str++ == '\n') num_lines++;
618: }
619:
620: *newlines = num_lines;
621:
622: if (num_lines <= 1) return FALSE; /* Don't bother jump scrolling */
623:
624: /* Would this fill the screen? */
625:
626: if (num_lines >= height) {
627: *scroll = verybig;
628: return TRUE;
629: }
630:
631: /* Calculate the number of lines left in the window */
632:
633: lines_left = height - (t->last_line - t->first_line + 1);
634: if (lines_left >= height) lines_left -= height;
635:
636: /* Figure out how many lines to scroll */
637:
638: num_lines -= lines_left;
639:
640: if (num_lines <= 0) return FALSE; /* Enough room already */
641:
642: *scroll = num_lines;
643: return TRUE;
644: }
645:
646: /* Clear a number of lines in the window data structure */
647:
648: Clear_lines (t, scroll)
649: register TextWindow *t;
650: register int scroll;
651: {
652: register int i, start = t->first_line;
653: register int height = t->num_lines;
654:
655: /* If this would fill the screen, clear it instead */
656:
657: if (scroll >= t->height ) {
658: TextClear (t);
659: return;
660: }
661:
662: /* Shift the contents */
663:
664: t->first_line += scroll;
665: if (t->first_line >= height) t->first_line -= height;
666:
667: /* Now clear the blank lines */
668:
669: for (i = 0; i < scroll; i++) {
670: t->lines[start][0] = '\0';
671: t->line_chars[start] = 0;
672: t->line_length[start] = mar_width; /* Allow a left margin */
673: start++;
674: if (start >= height) start = 0;
675: }
676: }
677:
678: /* Store the characters of a string in the window and update the screen,
679: but only if dont_update isn't set */
680:
681: Do_text_string (t, str)
682: register TextWindow *t;
683: char *str;
684: {
685: register char *ch = str;
686: register char *curline = t->lines[t->last_line];
687: register int curchar = t->last_char;
688: register int x = t->next_x;
689: register FontInfo *f = t->font;
690: int start_x = t->next_x, start = curchar,
691: minch = f->firstchar, maxch = f->lastchar;
692:
693: /* First store the characters in the line */
694:
695: while (*ch != '\0' && curchar < t->num_chars) {
696: curline[curchar] = *ch;
697: if (*ch >= minch && *ch <= maxch) {
698: x += f->fixedwidth ? f->width : f->widths[*ch - minch];
699: }
700: curchar++;
701: ch++;
702: }
703:
704: curline[curchar] = '\0';
705: t->line_chars[t->last_line] = t->last_char = curchar;
706: t->line_length[t->last_line] = t->next_x = x;
707:
708: if (dont_update || !t->mapped) return;
709:
710: /* And then update the screen */
711:
712: if (start < t->num_chars) {
713: XText (t->w, start_x, t->next_y, str, curchar-start,
714: f->id, t->fgpixel, t->bgpixel);
715: }
716: }
717:
718: /* Textputchar displays a character in the text window. It
719: * responds to \n as a special character and just displays anything else.
720: */
721:
722: TextPutChar (t, ch)
723: register TextWindow *t;
724: char ch;
725: {
726: register int i, height = t->num_lines;
727: register char *curline = t->lines[t->last_line];
728: register FontInfo *f = t->font;
729:
730: switch (ch) {
731: case '\0': /* NULL */
732: break;
733:
734: case '\n': /* newline */
735: if (t->last_line == t->first_line - 1 ||
736: (t->last_line == height - 1 && t->first_line == 0)) {
737:
738: /* The screen is full...clear out the first line */
739:
740: t->lines[t->first_line][0] = '\0';
741: t->line_chars[t->first_line] = 0;
742: t->line_length[t->first_line] = mar_width;
743:
744: t->first_line++; /* And advance it */
745: if (t->first_line == height) t->first_line = 0;
746:
747: if (!dont_update && t->mapped) Scroll_text_window (t, 1);
748:
749: } else if (!dont_update) t->next_y += f->height;
750:
751: t->last_line++;
752: if (t->last_line == height) t->last_line = 0;
753:
754: t->last_char = 0;
755: t->next_x = mar_width;
756: break;
757:
758: default: /* Just insert the character */
759: t->last_char++;
760: t->line_chars[t->last_line]++;
761: if (t->last_char > t->num_chars) break;
762:
763: curline[t->last_char] = ch;
764: curline[t->last_char+1] = '\0';
765:
766: if (!dont_update && t->mapped) {
767: XText(t->w, t->next_x, t->next_y, &ch, 1,
768: f->id, t->fgpixel, t->bgpixel);
769: }
770: if (ch <= f->firstchar && ch >= f->lastchar) {
771: t->line_length[t->last_line] = t->next_x +=
772: (f->fixedwidth ? f->width :
773: f->widths[ch - f->lastchar]);
774: }
775: break;
776: }
777: }
778:
779: /* This procedure moves the contents of a text window up n lines.
780: */
781:
782: Scroll_text_window (t, n)
783: register TextWindow *t;
784: register int n;
785: {
786: register int i, y, x, width, j;
787: int height = t->font->height;
788: int scrollsize = n * height;
789:
790: /* First shift up the contents */
791:
792: XMoveArea(t->w, 0, scrollsize, 0, 0, t->width, t->height-scrollsize);
793:
794: /* Now redisplay the bottom n lines */
795:
796: y = height * (t->num_lines - n);
797: i = t->first_line - n;
798: if (i < 0) i += t->num_lines;
799:
800: for (j = 0; j < n; j++) {
801: if (t->line_chars[i]) {
802: XText (t->w, mar_width, y, t->lines[i], t->line_chars[i],
803: t->font->id, t->fgpixel, t->bgpixel);
804: }
805: x = t->line_length[i];
806: width = t->width - x;
807:
808: if (width > 0) XPixSet(t->w, x, y, width, height, t->bgpixel);
809: y += height;
810: i++;
811: if (i == t->num_lines) i = 0;
812: }
813:
814: /* Add the current scroll to all values in the scroll history,
815: then add a new entry at the end (the history wraps!) */
816:
817: i = t->scroll_start;
818:
819: for (j = 0; j < t->scroll_count; j++) {
820: t->scroll_history[i] += n;
821: i++;
822: if (i >= t->num_lines) i = 0;
823: }
824: t->scroll_count++;
825: t->scroll_history[i] = n;
826:
827: if (t->scroll_count > t->num_lines) t->scroll_start++; /* trash one */
828: }
829:
830: #define TEXT_BUFSIZE 2048
831:
832: TextPrintf(t, format, args)
833: TextWindow *t;
834: char *format;
835: {
836: char buffer[TEXT_BUFSIZE+1];
837: struct _iobuf _strbuf;
838:
839: _strbuf._flag = _IOWRT+_IOSTRG;
840: _strbuf._ptr = buffer;
841: _strbuf._cnt = TEXT_BUFSIZE;
842: _doprnt(format, &args, &_strbuf);
843: _strbuf._cnt++; /* Be sure there's room for the \0 */
844: putc('\0', &_strbuf);
845: TextPutString(t, buffer);
846: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.