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